Leetcode js implementation

String 中部分字母替换成大写

let inputArray = "Who Love Solo OOO".split(" ");
let lower = ["a", "e", "i", "o", "u"]; //替换这些字母为大写
function doFunc(arr) {
  let new_arr = [];
  let new_arr_join = arr.join().toLowerCase().split("");
  // console.log(new_arr_join);
  for (let i = 0; i < new_arr_join.length; i++) {
    if (lower.includes(new_arr_join[i])) {
      new_arr.push(new_arr_join[i].toUpperCase());
    } else {
      new_arr.push(new_arr_join[i]);
    }
  }
  console.log(new_arr.join("").replace(/,/g, " "));
}

doFunc(inputArray); //whO lOvE sOlO OOO

用 String 加很大的数（add large num use string）

let sum_string = function (num1, num2) {
  let i = num1.length - 1,
    j = num2.length - 1,
    add = 0;
  const ans = [];
  while (i >= 0 || j >= 0 || add != 0) {
    let a = 0,
      b = 0;
    if (i >= 0) {
      a = num1.charAt(i) - "0";
    } else {
      a = 0;
    }
    if (j >= 0) {
      b = num2.charAt(j) - "0";
    } else {
      b = 0;
    }
    let re = a + b + add;
    ans.push(re % 10);
    add = Math.floor(re / 10);
    i -= 1;
    j -= 1;
  }
  return ans.reverse().join("");
};

let a = "99999999999999999999999999999999999999999999999999999999999";
let b = "999999999999999999999999999999999999999999999999999999999";

let result = sum_string(a, b);

console.log(result);

数组反转

const reverse = (arr) => {
  return arr.reverse().join("");
};

对 string 全排列 并删除 相同（重复）元素，输出最终不同的全排列个数

let inputArray = "ABCDEFGHHA".split("");
//删除数组中相同（重复）的元素
function remove(arr) {
  return Array.from(new Set(arr));
}
//全排列
function permutate(str) {
  var result = [];
  if (str.length == 1) {
    return [str];
  } else {
    var preResult = permutate(str.slice(1));
    for (var j = 0; j < preResult.length; j++) {
      for (var k = 0; k < preResult[j].length + 1; k++) {
        var temp = preResult[j].slice(0, k) + str[0] + preResult[j].slice(k);
        result.push(temp);
      }
    }
    return result;
  }
}
//n！ jiecheng
function n_(x) {
  if (x < 2) {
    return 1;
  } else {
    return x * n_(x - 1);
  }
}

function doFunc(arr) {
  let join_arr = arr.join("");
  console.log(remove(permutate(join_arr)).length);
}

doFunc(inputArray);

// ABA,AAB,BAA

数组小到大排序

function(arr){
    return arr = arr.sort((a, b) => a[0] - b[0]);
}

输出数的因子乘积等于该数的 数组

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.question("", function (line) {
  let number = parseInt(line);
  factor(number);
  rl.close();
});

function factor(num) {
  let result = "";
  for (let i = 2; i * i <= num && i <= num; i++) {
    while (num % i === 0) {
      result += i + " ";
      num /= i;
    }
  }
  if (num > 1) result += num + " ";

  console.log(result);
}

给定一个数组和一个目标和，从数组中找两个数字相加等于目标和，输出这两个数字的下标。

function twoSum(nums, target) {
  let ans = [];
  for (let i = 0; i < nums.length; i++) {
    for (let j = i + 1; j < nums.length; j++) {
      if (nums[i] + nums[j] == target) {
        ans[0] = [i, nums[i]];
        ans[1] = [j, nums[j]];
        return ans;
      }
    }
  }
  return ans;
}

let nums = [0, 0, 0, 5, 6, 7, 8];

let target = 9;

console.log(twoSum(nums, target));

插入排序

//小到大
function insertionSort(arr) {
  var len = arr.length;
  var preIndex, current;
  for (var i = 1; i < len; i++) {
    preIndex = i - 1;
    current = arr[i];
    while (preIndex >= 0 && arr[preIndex] > current) {
      arr[preIndex + 1] = arr[preIndex];
      preIndex--;
    }
    arr[preIndex + 1] = current;
  }
  return arr;
}

let nums = [0, 20, 0, 5, 6, 7, 8];
console.log(insertionSort(nums));

选择排序

function selectionSort(arr) {
  var len = arr.length;
  var minIndex, temp;
  for (var i = 0; i < len - 1; i++) {
    minIndex = i;
    for (var j = i + 1; j < len; j++) {
      if (arr[j] < arr[minIndex]) {
        // 寻找最小的数
        minIndex = j; // 将最小数的索引保存
      }
    }
    temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
  return arr;
}

进制转换

// 如果要处理2进制到10进制，16进制到10进制，8进制到10进制， 需要用了paresInt这个方法

//2进制到10进制；
parseInt(10, 2); //=>2
//2进制到10进制；
parseInt(100, 2); //=>4
//16进制到10进制
parseInt(12, 16); //=>18
//8进制到10进制
parseInt(12, 8); //=>10

//js的进制转换， 分为2进制，8进制，10进制，16进制之间的相互转换， 我们直接利用 对象.toString()即可实现：
//10进制转为16进制
(10)
  .toString(16)(
    // =>"a"
    //8进制转为16进制
    012,
  )
  .toString(16)(
    // =>"a"
    //16进制转为10进制
    0x16,
  )
  .toString(10)(
    // =>"22"
    //16进制转为8进制
    0x16,
  )
  .toString(8)(
    // =>"26"
    //10进制转为2进制 //=>
    1111,
  )
  .toString(2)(
    // => "10001010111"
    //8进制转为2进制 //=>
    01111,
  )
  .toString(2)(
    //=>"1001001001"
    //16进制转为2进制 //=>
    0x16,
  )
  .toString(2); // => "10110"

删除数组中相同（重复）的元素

const arr = [5, 1, 5, 7, 7, 5];
const unique = [...new Set(arr)]; // [ 5, 1, 7 ]

js 中能改变值的二进制数组

// Element type	Bytes	Description	C type
// Int8	   1	8-bit signed integer	signed char
// Uint8	1	8-bit unsigned integer	unsigned char
// Uint8C	1	8-bit unsigned integer (clamped conversion)	unsigned char
// Int16	2	16-bit signed integer	short
// Uint16	2	16-bit unsigned integer	unsigned short
// Int32	4	32-bit signed integer	int
// Uint32	4	32-bit unsigned integer	unsigned int
// Float32	4	32-bit floating point	float
// Float64	8	64-bit floating point	double

const typedArray = new Float64Array([0, 1, 2]); //64位 8byte
console.log(typedArray.length); // 3
typedArray[0] = 5;
const normalArray = [...typedArray]; // [5,1,2]

// The elements are stored in typedArray.buffer.
// Get a different view on the same data:
const dataView = new DataView(typedArray.buffer);
console.log(dataView.getUint8(0)); // 5

按照从右向左的阅读顺序，返回一个不含重复数字的新的整数

HJ9 提取不重复的整数

let line = "2752771".split("").reverse().join("").split("");
while ((line = readline())) {
  var lines = line.split("").reverse().join("").split("");
  function remove(arr) {
    return [...new Set(arr)];
  }
  print(remove(lines).join(""));
}

字符转化为按 ascii 码(ASCII 码)

let str = "a".charCodeAt();
console.log(str); //97

HJ10 字符个数统计

对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3。

输出 输入字符串 中范围在(0~127，包括 0 和 127)字符的种数。

while ((line = readline())) {
  var lines = line.split("");
  let count = 0;
  function remove(arr) {
    return [...new Set(arr)];
  }
  lines = remove(lines);
  for (let i = 0; i < lines.length; i++) {
    if (lines[i].charCodeAt() >= 0 && lines[i].charCodeAt() <= 127) {
      // console.log(lines[i]);
      count++;
    }
  }
  print(count);
  // console.log(count);
}

数字颠倒

while ((line = readline())) {
  var lines = line.split("");
  console.log(lines.reverse().join(""));

  // print();
}

HJ12 字符串反转

node.js 实现

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
rl.on("line", function (line) {
  const tokens = line.split("");
  console.log(tokens.reverse().join(""));
});

const reverse = (arr) => {
  return arr.reverse().join("");
};

HJ13 句子逆序

输入一个英文语句，每个单词用空格隔开。保证输入只包含空格和字母。

输出描述： 得到逆序的句子

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
rl.on("line", function (line) {
  const tokens = line.split(" ");
  console.log(tokens.reverse().join(" "));
});

const reverse = (arr) => {
  return arr.reverse().join("");
};

HJ14 字符串排序

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
let i = 0;
var long = 0;
rl.question("", function (line) {
  long = parseInt(line);
});
var arr = [];
rl.on("line", function (line) {
  i += 1; //每输入完一行i++
  arr.push(line);
  if (i == long) {
    //等于第一行的输入值的时候停止输入
    for (var j = 0; j < arr.length; j++) {
      console.log(sort_arr(arr)[j]);
    }
    rl.close();
  }
});
const sort_arr = (arr) => {
  return arr.sort(); //按字母排序
};

HJ15 求 int 型正整数在内存中存储时 1 的个数

//node.js 
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
let i;
rl.question("", (line) => {
  i = parseInt(line).toString(2); //转化为2进制
  let count = 0;
  i.toString()
    .split("")
    .forEach((e) => {
      if (e === "1") {
        count += 1;
      }
    });
  console.log(count);
  rl.close();
});

//rust
fn main() {
    println!("{}",count4(300));
    println!("");
}
fn count4(mut n:i32) -> i32 {
    n = (n & 0x55555555) +((n>>1)&0x55555555);
    n = (n & 0x33333333) +((n>>2)&0x33333333);
    n = (n & 0x0f0f0f0f) +((n>>4)&0x0f0f0f0f);
    n = (n & 0x00ff00ff) +((n>>8)&0x00ff00ff);
    n = (n & 0x0000ffff) +((n>>16)&0x0000ffff);
    return n
}

合并两个有序链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    ListNode h = new ListNode(0);
    ListNode ans=h;
    while (l1 != null && l2 != null) {
        if (l1.val < l2.val) {
            h.next = l1;
            h = h.next;
            l1 = l1.next;
        } else {
            h.next = l2;
            h = h.next;
            l2 = l2.next;
        }
    }
    if(l1==null){
        h.next=l2;
    }
    if(l2==null){
        h.next=l1;
    }
    return ans.next;
}
}

数组中删除 element

public int removeElement(int[] nums, int val) {
    int i = 0;
    int n = nums.length;
    while (i < n) {
        if (nums[i] == val) {
            nums[i] = nums[n - 1];
            n--;
        } else {
            i++;
        }
    }
    return n;
}

List 全排列

class Solution {
    public List<List<Integer>> permute(int[] nums) {
    List<List<Integer>> all = new ArrayList<>();
    //从下标 0 开始的所有组合
    upset(nums, 0, all);
    return all;
}
private void upset(int[] nums, int begin, List<List<Integer>> all) {
    if (begin == nums.length) {
        ArrayList<Integer> temp = new ArrayList<Integer>();
        for (int i = 0; i < nums.length; i++) {
            temp.add(nums[i]);
        }
        all.add(new ArrayList<Integer>(temp));
        return;
    }
    for (int i = begin; i < nums.length; i++) {
        swap(nums, i, begin);
        upset(nums, begin + 1, all);
        swap(nums, i, begin);
    }
}
private void swap(int[] nums, int i, int begin) {
    int temp = nums[i];
    nums[i] = nums[begin];
    nums[begin] = temp;
}
}

给两个有序数组，把第二个数组合并到第一个数组中，保持有序。

class Solution {
   public void merge(int[] nums1, int m, int[] nums2, int n) {
    int i = m - 1; //从末尾开始
    int j = n - 1; //从末尾开始
    int k = m + n - 1; //从末尾开始
    while (j >= 0) {
        if (i < 0) {
            while (j >= 0) {
                nums1[k--] = nums2[j--];
            }
            return;
        }
        //哪个数大就对应的添加哪个数。
        if (nums1[i] > nums2[j]) {
            nums1[k--] = nums1[i--];
        } else {
            nums1[k--] = nums2[j--];
        }
    }
}
}

判断是否有重复数字。

public boolean containsDuplicate(int[] nums) {
    HashSet<Integer> set = new HashSet<>();
    for (int i = 0; i < nums.length; i++) {
        if (set.contains(nums[i])) {
            return true;
        }
        set.add(nums[i]);
    }
    return false;
}

给一个二叉搜索树，找到树中第 k 小的树。二叉搜索树的定义如下：

若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 任意节点的左、右子树也分别为二叉查找树； 没有键值相等的节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

int num = 0;
int res;
public int kthSmallest(TreeNode root, int k) {
    inorderTraversal(root, k);
    return res;
}
private void inorderTraversal(TreeNode node, int k) {
    if (node == null) {
        return;
    }
    inorderTraversal(node.left, k);
    num++;
    if (num == k) {
        res = node.val;
        return;
    }
    inorderTraversal(node.right, k);
}

最长上升子序列的长度。

public int lengthOfLIS(int[] nums) {
    int n = nums.length;
    if (n == 0) {
        return 0;
    }
    int dp[] = new int[n];
    int len = 0;
    for (int i = 0; i < n; i++) {
        int start = 0;
        int end = len;
        while (start < end) {
            int mid = (start + end) >>> 1;
            if (dp[mid] < nums[i]) {
                start = mid + 1;
            } else {
                end = mid;
            }
        }
        dp[start] = nums[i];
        if (start == len) {
            len++;
        }
    }
    return len;
}

将所有的 0 移动到末尾，并且保持其他数字的相对顺序不变。

public void moveZeroes(int[] nums) {
    int j = 0;
    for (int i = 0; i < nums.length; i++) {
        //不等于 0 就交换
        if (nums[i] != 0) {
            int temp = nums[j];
            nums[j] = nums[i];
            nums[i] = temp;
            j++;
        }
    }
}

数组nums包含从0到n的所有整数，但其中缺了一个。请编写代码找出那个缺失的整数。在O(n)时间内完成

```js
数组nums包含从0到n的所有整数，但其中缺了一个。
请编写代码找出那个缺失的整数。在O(n)时间内完成
```;
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
let long = [];
rl.question("", function (line) {
  long = line.split(",");
  console.log(miss_one(long));
  rl.close();
});

function miss_one(arr) {
  let data = 0;
  for (let i = 0; i < arr.length; i++) {
    //先用0异或0~nums.length的下标
    data ^= i;
    //再异或元素，一个数字出现两次，异或后为0，而异或最终的结果值为出现一次的数，即为缺失的元素
    data ^= parseInt(arr[i]);
    // console.log(data);
  }
  data ^= arr.length;
  return data;
}

数组求最大值

function getMax(arr) {
  return Math.max.apply(null, arr);
}

统计数组中的元素出现次数

let data = [1, 1, 2, 3, 1, 2, 45, 21];
let objGroup = data.reduce(function (obj, name) {
  obj[name] = obj[name] ? ++obj[name] : 1;
  return obj;
}, {});
console.log(objGroup); //{ "1": 3, "2": 2, "3": 1, "21": 1, "45": 1 }
console.log(Object.entries(objGroup)); //[ [ "1", 3 ], [ "2", 2 ], [ "3", 1 ], [ "21", 1 ], [ "45", 1 ] ]
console.log(Object.keys(objGroup)); //[ "1", "2", "3", "21", "45" ]
console.log(Object.values(objGroup)); //[ 3, 2, 1, 1, 1 ]

已知圆中心,求半径问题

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
let i = 0;
var long = 0;
rl.question("", function (line) {
  long = parseInt(line);
});
var x = [];
var y = [];
rl.on("line", function (line) {
  i += 1;
  x.push(parseInt(line.split(" ")[0]));
  y.push(parseInt(line.split(" ")[1]));
  if (i == long) {
    console.log(main(x, y));
    rl.close();
  }
});

function main(_x, _y) {
  // let _x = [2, -2, 3, -3, 1,2,-1];
  // let _y = [-3, -3, 0, -1, -2, -2, 0];
  let result = [];
  for (let i = 0; i < _x.length; i++) {
    for (let j = 0; j < _x.length; j++) {
      result.push(
        Math.pow(Math.pow(_x[i] - _x[j], 2) + Math.pow(_y[i] - _y[j], 2), 0.5) /
          2,
      );
    }
  }
  let radius = result.filter((x) => {
    return x !== 0;
  }).sort();
  const unique = [
    ...new Set(
      result.filter((x) => {
        return x !== 0;
      }).sort(),
    ),
  ];
  console.log(unique);
  let objGroup = radius.reduce(function (obj, name) {
    obj[name] = obj[name] ? ++obj[name] : 1;
    return obj;
  }, {});
  console.log(Object.entries(objGroup));

  function getMax(arr) {
    return Math.max.apply(null, arr);
  }
  let max_count = getMax(Object.values(objGroup));
  let max_index = Object.values(objGroup).lastIndexOf(max_count);

  return Object.entries(objGroup)[max_index][0];
}

位数相加，直到和位个位数

function digital_root(n) {
  // ...
  let data = n
    .toString()
    .split("")
    .map((x) => {
      return parseInt(x);
    });
  let sum = 0;
  data.forEach((x) => {
    sum += x;
  });
  return sum < 9 ? sum : digital_root(sum);
}
//1+6+4=11
//1+1=2
//return 2
console.log(digital_root(164));