1 JavaScript

1.1 Reduce

// 数组去重
let arr = [1,2,3,4,4,1]
let newArr = arr.reduce((pre,cur)=>{
    if(!pre.includes(cur)){
      return pre.concat(cur)
    }else{
      return pre
    }
},[])
console.log(newArr);// [1, 2, 3, 4]

1.2 ValueOf

var a = {
  value: 0,
  valueOf() {
    this.value++;
    return this.value;
  }
}
if(a==1 && a==2 && a==3) {
  console.log('true'); // 输出true
}

1.3 无重复字符串的排列组合

var permutation = function(S) {
  var temp = S.split(''); //字符串转为数组
  len = temp.length;//长度
  var res = []; //结果
  dfs(0);
  return res;
  function dfs(k) {
    if(k == len) { //结束条件
      res.push(temp.join('')); //加入结果
      return;
    }
    for(let i = k; i < len; i++) {
      [temp[i], temp[k]] = [temp[k], temp[i]]; //交换位置
      dfs(k + 1);                              //递归
      [temp[i], temp[k]] = [temp[k], temp[i]]; //回溯
    }
  }
};

1.4 Map

let map = new Map
map.has(key) // boolean
map.get(key) // key.val
map.set(key, val) // set (key, val)
map.delete(key) // delete
map.keys() // key的集合
map.keys().next().value // key里面第一个，适合LRU delete(map.keys().next())
// 再次强调，这里.value不是取val，依然是第一个key

1.5 翻转链表

var reverseList = function(head) {
    let prev = null;
    let curr = head;
    while (curr) {
        const next = curr.next; // 先提前保存next
        curr.next = prev; // 规定现在的后面，是之前的那坨
        prev = curr; // 把新的整坨，给prev（也就是最后要提交的
        curr = next; // 把刚刚存的next给到curr，继续循环
    }
    return prev;
};

1.6 K个一组翻转链表

const myReverse = (head, tail) => {
  let prev = tail.next;
  let p = head;
  while (prev !== tail) {
    const nex = p.next;
    p.next = prev;
    prev = p;
    p = nex;
  }
  return [tail, head];
}

var reverseKGroup = function(head, k) {
  const hair = new ListNode(0);
  hair.next = head;
  let pre = hair;

  while (head) {
    let tail = pre;
    // 查看剩余部分长度是否大于等于 k
    for (let i = 0; i < k; ++i) {
      tail = tail.next;
      if (!tail) {
        return hair.next;
      }
    }
    const nex = tail.next;
    [head, tail] = myReverse(head, tail);
    // 把子链表重新接回原链表
    pre.next = head;
    tail.next = nex;
    pre = tail;
    head = tail.next;
  }
  return hair.next;
};

1.7 LRU缓存

var LRUCache = function(capacity) {
    this.capacity = capacity;
    this.map = new Map(); // 本质是map
};

LRUCache.prototype.get = function(key) {
    if(this.map.has(key)){
      // 如果找到了，也要删掉重搞，temp存一下
      let temp=this.map.get(key)
      this.map.delete(key);
      this.map.set(key, temp);
      return temp
    }else{
      return -1
    }
};

LRUCache.prototype.put = function(key, value) {
    if(this.map.has(key)){
      // 如果已经有这个key了，删了重搞
      this.map.delete(key);
    }
    this.map.set(key,value);
    if(this.map.size > this.capacity){
      // keys.next很巧妙的取到了第一个
      this.map.delete(this.map.keys().next().value);
    }
};

1.8 快排

const QuickSort = (ElemType A[],int low, int high) => {
    if(low < high){
        int pivotpos = Partition(A,low,high);
        QuickSort(A,low,pivotpos-1);
        QuickSort(A,pivotpos+1,high);
    }
}

const Partition(ElemType A[],int low,int high){
    ElemType pivot = A[low];
    while(low<high){
        while(low<high && A[high] >= pivot)
            --high;
        A[low] = A[high];
        while(low<high && A[low] <= pivot)
            ++low;
        A[high] = A[low];
    }
    A[low] = pivot;
    return low;
}

1.9 最大子数组和

var maxSubArray = function(nums) {
    let pre = 0, maxAns = nums[0];
    nums.forEach((x) => {
        pre = Math.max(pre + x, x);
        maxAns = Math.max(maxAns, pre);
    });
    return maxAns;
};

1.10 字符串算式

// 题目：输入一个字符串算式，包括括号，计算值并输出
var calculate = function(s) {
    const nums = []
    let cur = 0
    let prevOp = '+'
    s = s + '+'

    for (let i = 0; i < s.length; i++) {
        if (s[i] >= '0' && s[i] <= '9') {
            cur = cur * 10 + s[i].charCodeAt(0) -'0'.charCodeAt(0)
        } else if (s[i] == ' ') {
            continue
        } else {
            if (prevOp == '+') { 
                nums.push(cur)
            } else if (prevOp == '-') {
                nums.push( -1 * cur) 
            } else if (prevOp == '*') {
                nums[nums.length - 1] *=  cur 
            } else if (prevOp == '/') {
                nums[nums.length - 1]  =  (nums[nums.length - 1] / cur) | 0
            }
            prevOp = s[i] 
            cur = 0 
        }
    }
    let sum = 0
    nums.forEach(v => {
        sum += v
    })
    return sum
};

1.11 无根树直径

// 给出一棵n个节点的无根树，现在你每次可以选择一个叶子节点，然后将其删除。
// 问至少需要删除多少个叶子节点，才可以使得这棵树的直径不超过k.
// 树的直径定义:树上最远的两点距离。

1.12 同一个函数调用不同值

// 根据传入字符串创建一个循环输出字符的方法，每次调用该方法时返回下一个字符，
// 全部返回完毕后从头部重新开始

let count = -1
function loopString(str) {

  return () => {
    count++
    if (count >= str.length) {
      count = 0
    }
    return str[count]
  }
}


try {
  const bar = loopString('bar');
  assert.strictEqual(bar(), 'b');
  assert.strictEqual(bar(), 'a');
  assert.strictEqual(bar(), 'r');
  assert.strictEqual(bar(), 'b');
  console.log('通过');
} catch (err) {
  console.log(err)
  console.log('不通过');
}

1.13 计算器（对象版）

function myCalculator(num) {
  return Object({
    value: num,
    getValue: function () {
        return this.value
    },
    add: function (val) {
      this.value += val
      return this
    },
    minus: function (val) {
      this.value -= val
      return this
    },
    multi: function (val) {
      this.value *= val
      return this
    },
    div: function (val) {
      this.value /= val
      return this
    }
    })
}


try {
  assert.deepEqual(myCalculator(121).getValue(), 121);
  assert.deepEqual(myCalculator(121).add(1).getValue(), 122);
  assert.deepEqual(myCalculator(121).add(1).minus(2).multi(3).div(4).getValue(), 90);
  console.log('通过');
} catch (err) {
  console.error(err);
  console.log('不通过');
}

1.14 最大硬度

/*
成品至少包含两层材料，第一层和最后一层材料的硬度应该相同，在加工的过程中，可以分离去除任意层材料，使得剩下的材料满足成品的要求。成品的硬度是其中各层材料的硬度之和。请返回成品可能得到的最大硬度。
ex: board = [3,1,4,3,1] // 11
*/
function getMaxHard() {

}

1.15 攀岩最短路径

/*
攀岩路线上共有n个点
若strengthli]>=0时,表示到达编号i的点需要消耗的体力值
若strength[i]==-1时,表示不可到达至该点
当选手位于编号j的攀岩点时，可以向上至j+1~j+limit中任一有效攀岩点,
请找出选手从起点至终点消耗体力值最少的路径，并依次输出所有经过的编号(从1到n)。若不存在从起点至终点的路径，请返回空数组。
输入:strength =[41,2,-1,2], limit = 2
输出:[1,3,5]
解释: [4,1,2,-1,2]选手从起点至终点消耗体力值最少的路径为4->2->2,因此返回经过的编号[1,3,5]。
5例2:
输入:strength =2.-1.-1，-1,21， limit=3输出:
释:由于编号2、3、4外的占均干法到达。因此不存在开法从起占至终点的路径，返回空数组
*/
function getMinPath() {

}

2 Java

2.1 HashMap

//基础示例
HashMap<Character, Integer> dic = new HashMap<>();
for (int i = 0; i < len1; i++) {
    dic.put(s1.charAt(i) , dic.getOrDefault(s1.charAt(i), 0) + 1);
}
//存值
dic.put("somekey", 1);
//取值
dic.get("somekey");
//判断是否为空
dic.isEmpty();
//判断是否有某个key
dic.containsKey("somekey");
//判断是否有某个value
dic.containsKey(1);
//删除这个key值下的value
dic.remove("1")

2.2 StringBuilder

public String replaceSpaces(String S, int length) {
        StringBuilder stringBuilder = new StringBuilder();
        //逐渐遍历字符串
        for (int i = 0; i < length; i++) {
            //如果不是空格就加入到StringBuilder中，如果是空格
            //就把"%20"加入到StringBuilder中
            char ch = S.charAt(i);
            if (ch == ' ') {
                stringBuilder.append("%20");
            } else {
                stringBuilder.append(ch);
            }
        }
        return stringBuilder.toString();
    }

2.3 LinkedList

import java.util.LinkedList;

public class AnimalShelf {
  LinkedList<int[]> queue;

  public AnimalShelf() {
    queue = new LinkedList<>();
  }

  public void enqueue(int[] animal) {
    queue.offer(animal);
  }

  public int[] dequeueAny() {
    return queue.isEmpty() ? new int[] {-1, -1} : queue.poll();
  }

  public int[] dequeueDog() {
    int[] dog = {-1, -1};
    for (int[] ani : queue) {
      if (ani[1] == 1) {
        dog = ani;
        break;
      }
    }
    queue.remove(dog);
    return dog;
  }

  public int[] dequeueCat() {
    int[] cat = {-1, -1};
    for (int[] ani : queue) {
      if (ani[1] == 0) {
        cat = ani;
        break;
      }
    }
    queue.remove(cat);
    return cat;
  }
}

3 其他

3.1 Cookie相关—xgz

// secret!
var jwtSecret = []byte("fLA0Yxm2fs6XLSZu")

type Claims struct {
    Id                 int // 用户id
    jwt.StandardClaims     // 基类claims
}

// 生成token
func generateToken(form *loginForm) (string, error) {
    now := time.Now()

    claims := Claims{
        form.Id,
        jwt.StandardClaims{
            IssuedAt: now.Unix(),
            // 过期时间为三天
            ExpiresAt: now.Add(time.Hour * 24 * 3).Unix(),
            Issuer:    "lucario.ltd",
        },
    }
    tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    token, err := tokenClaims.SignedString(jwtSecret)

    return token, err
}

// ParseToken 验证token中间件
func ParseToken(c *gin.Context) {
    tokenClaims, err := jwt.ParseWithClaims(c.GetHeader("token"), &Claims{}, func(token *jwt.Token) (interface{}, error) {
        return jwtSecret, nil
    })
    if err != nil {
        c.Set("id", -1)
    } else {
        // 解密token
        claims, ok := tokenClaims.Claims.(*Claims)
        // 解密成功
        if ok && tokenClaims.Valid {
            c.Set("id", claims.Id)
        } else {
            c.Set("id", -1)
        }
    }
}

// Authorize 验证是否登录
func Authorize(c *gin.Context) {
    id := c.GetInt("id")
    // 未登录
    if id <= 0 {
        api.Error(c, errors.New("请先登录"), http.StatusUnauthorized)
    }
}

3.2 ACM模式的编程写法

var m;
var sum,n;
var sc

while(sc = read_line()){
    var arr = sc.split(' ');
  n=parseInt(arr[0]);
  m=parseInt(arr[1]);
  sum=0;
  for(var i=0;i<m;i++){
      sum=sum+n;
      n=Math.sqrt(n);
  }
  print(sum.toFixed(2));
}

var sc;
while(sc = read_line()){
    var arr = sc.split(' ');
    n=parseInt(arr[1]);
    m=parseInt(arr[0]);
    if(100<=m&&m<=n&&n<=999){
        var out = [];
        var j=0;
        for(var i=m;i<=n;i++)
        {
            var geWei,shiWei,baiWei;
            baiWei=parseInt(i/100);
            shiWei=parseInt((i-baiWei*100)/10);
            geWei=i-baiWei*100-shiWei*10;
            if(i==geWei*geWei*geWei+shiWei*shiWei*shiWei+baiWei*baiWei*baiWei)
            {
                j=j+1;
                if(j>1){
                    out.push(" "+i);
                }
                else{
                    out.push(i);
                }
            }
        }
        if(j==0){
            out.push("no");
        }
        print(out.join(''));
    }
}

coderV

算法杂记

1 JavaScript

1.1 Reduce

1.2 ValueOf

1.3 无重复字符串的排列组合

1.4 Map

1.5 翻转链表

1.6 K个一组翻转链表

1.7 LRU缓存

1.8 快排

1.9 最大子数组和

1.10 字符串算式

1.11 无根树直径

1.12 同一个函数调用不同值

1.13 计算器（对象版）

1.14 最大硬度

1.15 攀岩最短路径

2 Java

2.1 HashMap

2.2 StringBuilder

2.3 LinkedList

3 其他

3.1 Cookie相关—xgz

3.2 ACM模式的编程写法