LeetCode

​ 力扣

最早的在线评测系统是由西班牙Valladolid大学的Ciriaco García de Celis于1995年开发的，当时用于该校参加ACM/ICPC西南欧区域赛选拔队员。 现在较为著名的在线评测系统有洛谷，西班牙的UVaOJ、俄罗斯的SGU、Timus、Codeforces、波兰的SPOJ、美国的TopCoder、中国的POJ（北京大学）、ZOJ（浙江大学）、HDOJ（杭州电子科技大学）。 不同群体中不同OJ使用的频率也不同，学生中常会因为教师的要求使用公开/校内OJ，为此，许多公开OJ也提供了个性化服务，如Vijos中的“域”服务，OpenJudge、洛谷、Vjudge中的团队服务。 在特定群体中亦有一些流行的在线评测系统，例如中国初中选手中流行的Vijos、进阶选手使用的BZOJ（现称“耒阳大视野”）、hihocoder、美国求职者中流行的LeetCode等。

在线评测系统

（英语：Online Judge，缩写OJ）是一种在编程竞赛中用来测试参赛程序的在线系统，也可以用于平时练习。近年来（2016年或更早）亦出现一些针对求职面试的在线评测系统。许多OJ网站会自发组织一些竞赛。此外，OJ网站通常会设立用户排名，以用户的提交答案通过数多少或某个题目执行时间快慢为排名依据.

在在线评测系统中，用户需要提交源代码至服务器，服务器会编译用户的源代码，然后执行源代码生成的可执行文件（或用解释方式执行，或直接执行脚本文件），得到其输出的结果，并与正确结果比较。 为防止攻击和恶意提交，服务器必须采取一定的安全措施，例如对用户提交的源代码实施过滤、将进程放入沙盒以进行隔离、对代码进行哈希以防止抄袭和重复提交等

​ 黑盒测试，软件测试的主要方法之一，也可以称为功能测试、数据驱动测试或基于规格说明的测试。测试者不了解程序的内部情况，不需具备应用程序的代码、内部结构和编程语言的专门知识。只知道程序的输入、输出和系统的功能，这是从用户的角度针对软件界面、功能及外部结构进行测试，而不考虑程序内部逻辑结构。测试案例是依应用系统应该做的功能，照规范、规格或要求等设计。测试者选择有效输入和无效输入来验证是否正确的输出。

此测试方法可适合大部分的软件测试，如集成测试（integration testing）以及系统测试（system testing）。

Virtual Judge-虚拟法官

Virtual Judge系统本身并没有任何测试数据，而是通过在其他在线评测系统中注册的机器人账号进行测试并抓取测试结果。因此可以在只有题目而没有测试数据的前提下创建竞赛。

常见的评测结果大致分为以下三类。

正在评测

• Pending：系统繁忙，用户程序正在排队等待。
• Pending Rejudge：因为数据更新或其他原因，系统将重新判你的答案.
• Compiling：正在编译。
• Running & Judging：正在运行并与标准数据进行比较。

程序未通过

• Wrong Answer（简称WA）：答案错误。
• Runtime Error（简称RE）：运行时错误，程序崩溃。
• Compile Error（简称CE）：编译错误。
• Time Limit Exceeded（简称TLE）：运行超出时间限制。
• Memory Limit Exceeded（简称MLE）：超出内存限制。
• Output Limit Exceeded（简称OLE）：输出的长度超过限制。
• Presentation Error（简称PE）：答案正确，但是输出格式不符合题目要求。在一些要求比较严格的比赛中，格式错也会被视为答案错误[2]。

程序通过

在评测过程中，只有未发生以上几种错误的情况下才算做通过。

• Accepted（简称AC）：程序通过。另外，在整场比赛中通过了所有题目又俗称“AK”或是“破台”。

一些比赛的测试点可以给出“部分分”，例如答案正确但不够优，或者选手没有完全完成题目所给的任务等

leetcode等OJ上Cpp的提交都以class solution而不是main函数作为入口?

优点1：可以真正地比较算法的效率， 传统的一些OJ，一道题会要求你读入数据，运行算法再输出结果，运行时间包括了“读入数据”和“输出结果”。 相信很多在OJ上刷题的筒子们多少碰到过这样的事情，（1）cin太慢了，加一句std::ios::sync_with_stdio(false); （2）scanf还是太慢了，自己写一个input函数。 LeetCode和TopCoder这样的OJ要求你写一个类的接口，在评测的时候可以有效避免计算I/O的时间。 至于为什么要写一个类包含特定接口而不是直接写一个函数，是为了避免你写的其他函数和评测系统的函数冲突。

优点2：更简单的Special Judge 如果输入的结果是整数、字符串那还好办，逐个字符比较就好了，但是是一个浮点数呢？传统的OJ一般采用Special Judge的方法，自己写一个文件读入标准Ouput的浮点数和你的结果输出的浮点数，再比较两个浮点数相差值是否在限定范围内，多解问题同理。 我们来梳理一下传统OJ的Special Judge的流程：

（1）你的程序读入input.txt；

（2）你的程序输出output.txt；

（3）Special Judge读入output.txt；

（4）Special Judge程序读入标准输出standard.txt；

（5）Special Judge程序比较output.txt和standard.txt；

（6）得出评测结果。 而LeetCode可以避免output.txt的I/O。 有人会说，这岂不是LeetCode每一题都要写Special Judge，差不多，但是它也可以写类似于传统OJ的逐字符比较的评测模版啊。

缺点1：在自己的电脑上运行测试样例有点麻烦。 诚然，LeetCode自己提供了运行简单样例的方法。但是，如果自己想看一下比较大的数据下自己的算法到底问题出在什么地方，显然倒腾自己的电脑更舒服。 LeetCode中，如果输入的是一组数，往往函数的参数是一个vector，自己再写一个读入转成vector难免有些难受。更甚，如果函数的参数是一个List等等，就更蛋疼了。

缺点2：提交的时候不小心就把自己的测试代码复制进去了。 自己写了个测试样例，提交的时候不小心把它包含进去了。题目里面链表已经定义了，提交的时候还有链表的定义。 这些问题挺常见的。可以通过加一个宏定义来解决，但是，不得不说，提交的时候把宏定义的注释给取消了这一步还是不可避免。相较之下，传统OJ就友善很多。

300 分钟搞定数据结构与算法

算法：

• 数据结构
• 工程

思路

• 算法能力能够准确辨别一个程序员的技术功底是否扎实

• 算法能力是发掘程序员的学习能力与成长潜力的关键手段

• 算法能力能够协助判断程序员分析并解决突发问题的能力

• 算法能力是设计一个高性能系统的必备基础

1-数据结构

• 数组、字符串

• 链表、队列

• 树、栈、图

• 前缀树、分段树、树状数组

2-常见算法

• 归并、快排、拓扑
• 二分查找、递归、回溯
• 广度与深度优先
• 动态规划

1.学算法的好处

学习算法的过程其实是一个提高思维能力的过程

2.如何应对算法面试

遇到新问题不要慌张,先想出最直观的解法;

直观解法大多数情况下不是最优的,却可以帮你打通思路

理清解决问题的各个步骤后,根据问题核心来优化某些步骤即可。

基本的排序算法【简单直接助你迅速写出没有bug的代码】

• 冒泡排序/ Bubble sort

• 插入排序/ Insertion Sort

常考的排序算法

• 归并排序/ Merge Sort

• 快速排序/ quick Sort

• 拓扑排序/ Topological Sort

其他排序算法

• 堆排序/ Heap Sort

• 桶排序/ Bucket sort

1递归的基本性质:函数调用本身

• 把大规模的问题不断地变小,再进行推导的过程

• 递归算法是一种调用自身函数的算法

  • 特点:可以使一个看似复杂的问题变得简洁和易于理解
  • 经典案例:汉诺塔(又称河內塔)

2回溯:利用递归的性质

• 从问题的起始点出发,不断尝试
• 返回一步甚至多步再做选择,直到抵达终点的过程

深度优先搜索算法(DFS)

• 假设我们有这么一个图,里面有A,B,C,D,E,F,G,H8个顶点

• 如何对这个图进行深度优先的遍历呢?

  1. 深度优先遍历必须依赖栈( Stack)这个数据结构

  2. 栈的特点是后进先出(LIFO）

先压入后访问每一个值，找到值之后，继续寻找，结束
弹出依次，找到没有访问的，
重复
最后弹出

广度优先搜索算法(BFS)

• 应用最多的地方是对图进行遍历(树也是图的一种)

动态规划

●基本属性

●题目分类

●解题思想

●巩固与加深:算法复杂度

动态规划的定义（维基百科的定义）

一种数学优化的方法,同时也是编程的方法

大问题

• 子问题1 -》子问题1最优解

• 子问题2 -〉子问题2最优解
• 子问题n-1 -》子问题n-1最优解
• 子问题n -〉子问题n最优解

最优解：通过数学方法，把子问题 转换成 最优解，（最优解组合）大事化了，小事化无

编程的 方法：可以保证我们求解的子问题只被求解一次

重要属性（满足动态规划）

• 最优子结构 Optimal Substructure
  • 状态转移方程f(n)
• 重叠子问题 Overlapping sub- problems（斐波那契数列）

二分搜索算法

• 看似简单,写对很难

• 变形很多

• 在面试中常用来考察code能力

贪婪算法

​ ●是一种比较直观的算法

​ ●难以证明它的正确性

定义：

• 二分搜索也称折半搜索,是一种在有序数组中查找某一特定元素的搜索算法

运用前提

• 数组必须是排好序的
• 输入并不一定是数组,也可能是给定一个区间的起始和终止的位置

优点

• 二分搜索也称对数搜索,其时间复杂度为O(lgn),是一种非常高效的搜索

缺点

• 要求待查找的数组或区间是排好序的

• 若要求对数组进行动态地删除和插入操作并完成查找,平均复杂度会变为O(n）

• 采取自平衡的二叉查找树

  • 可在O( nlogn)的时间内用给定的数据构建出一棵二叉查找树
  • 可在O(logn)的时间内对数据进行搜索
  • 可在O(logn)的时间内完成删除和插入的操作

  当:输入的数组或区间是有序的,且不会常变动,要求从中找出一个满足条件的元素—采用二分搜索

3.无重复字符的最长子串

给定一个字符串,请你找出其中不含有重复字符的最长子串的长度。

示例1:

输入:“ abcabcbb

输出:3

解释:因为无重复字符的最长子串是”abc”,其长度为3。

示例2:

输入:“ bbbbb

输出:1

解释:因为无重复字符的最长子串是”b”,其长度为1。

示例3:

输入:“ pwwkew”

输出:3

解释:因为无重复字符的最长子串是”wke”,其长度为3。

请注意,你的答案必须是子串的长度,”pwke”是一个子序列,不是子串。

解法一:暴力法

• 假设字符串长度为n

• 非空子串为n(n+1)/2

  • 长度为1的子串,有n个
  • 长度为2的子串,有n-1个
  • 长度为3的子串,有n-2个
  • 长度为k的子串,有n-k+1个
  • 当k=n时,n-k+1=1,即长度为n的子串就是1个
  • 所有情况全部相加,可得n+(n-1)+(n-2)+(n-3)+…+2+1 = n(n+1)/2
  • 算上空字符,共有(n+1)n/2+1

长度为n的字符串,一共有多少子序列?

• 子序列不同于子串
• 子序列中的与元素不需要相互挨着
  • 长度为1的子序列有n个,即Cl
  • 长度为2的子序列个数为C2
  • 长度为k的序列有Ck
  • 所有子序列的个数(包括空序列)为:C0+Cl+C2+.+C”=2n

大厂面试高频题精讲(二) ●合并区间+无重叠区间 ●火星字典 ●基本计算器

56.合并区间

给出一个区间的集合,请合并所有重叠的区间。

示例1:

输入:[[1,3],[2,6],[8,10],[15,18]]

输出:[[1,6],[8,10],[15,18]]

解释:区间[1,3]和[2,6]重叠,将它们合并为[1,6]

示例2

输入:[[1,4],[4,5]]

输出:[[1,5]]

解释:区间[1,4]和[4,5]可被视为重叠区间。

解题思路

• 假设有区间A和B,区间A的起始时间要早于B的起始时间。

• 那么它们之间有3种可能的重叠关系
• 情况一:A和B没有任何重叠部分,不会发生融合
• 情况二和三:区间有重叠
  • 新区间的起始时间是A的起始时间
  • 新区间的终止时间是A和B终止时间中的最大值
  • 这个就是融合两个区间的最基本的思想

给定了n个区间,我们应该怎么去有效地融合它们呢?

• 直观有效的做法
  • 先将所有的区间按照起始时间的先后顺序排序,从头到尾扫描一遍
  • 定义两个变量 previous和 current,分别表示前一个区间和当前的区间
    • 如果没有融合,当前区间就变成新的 previous,下一个区间成为新的 current
    • 如果发生了融合,更新前一个区间的结束时间

难题精讲(-） ●正则表达式匹配 ●柱状图中的最大矩形 ●实现 strstr()

10.正则表达式匹配

给你一个字符串S和一个字符规律p,请你来实现一个支持‘,′和‘*’的正则表达式匹配。
"." 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素

所谓匹配,是要涵盖整个字符串s的,而不是部分字符串。

说明:
5可能为空,且只包含从a-z的小写字母。
p可能为空,且只包含从a-z的小写字母,以及字符.和*。

示例1:
输入:
s="aa"
p="a"
输出: false
解释:"a"无法匹配"aa"整个字符串。


示例2:
输入:
s="aa"
p="a*"
输出:true
解释:因为‘*'代表可以匹配零个或多个前面的那一个元素,在这里前面的元素就是‘a′。
因此,字符串“a"可被视为‘a’重复了一次。

示例3:
输入:
s="ab"
p = ".*"
输出:true
解释:“,*”表示可匹配零个或多个("*")任意字符(‘.')。

示例4:
输入:
s= "aab"
p="c*a*b"
输出:true
解释:因为‘*'表示零个或多个,这里'c'为0个,
'a'被重复一次。因此可以匹配字符串"aab"。

示例5:
输入:
s='mississippi'
p = "mis*is*p*"
输出: false

336.回文对

给定一组唯一的单词,找出所有不同的索引对[i,j,使得列表中的两个单词,word[i]+word[j],可拼接成回文串。

示例1:
输入:
["abcd","dcba","lls","'s","'sssll'"]
输出:[[0,1],[1,0],[3,2],[2,4]]
解释:可拼接成的回文串为  ["dcbaabcd","'abcddcba","slls", "llssssll"]


示例2:
输入:["bat","tab","cat"]
输出:[[0,1],[1,0]]
解释:可拼接成的回文串为[" batta"," sabbat"]。

解题思路

回文:正读和反读都一样的字符串

检查字符串是否回文

• 翻转给定字符串后,对比原字符串,

  需要O(n)的空间复杂度

• 定义指针i指向字符串的头,定义指针j指向字符串的尾,

  从两头开始检查,发现不相等表明不是回文,

  直检查到两个指针相遇为止

boolean isPalindrome(String word, int i, int j){
while(i<j){
if(word.charAt(i++) != word.charAt(j--))
return false;}
return true
}

暴力法

• 找出所有的两两组合

• 对每种组合进行排查,寻找可以构成回文的组合

• 复杂度分析

  • 假设有n个单词,每个单词平均长度为k,从n个单词中选两个组合在一起排列,共有P(n,2)=n×(n-1)种
  • 对每个组合在一起的字符串进行回文检查,需要2k的时间复杂度,最终时间复杂度为O(n2×k)

刷题/ eetCode 你用什么编程语言刷题?

• Javascript 前端
• Java Python C++ 后端
• Python 数据分析工程师，涉及人工智能，机器学习

java

• 强类型语言

  • 能帮助我们更好地理解输入输岀要求

  • 对每个变量的类型都必须清楚

• 提供丰富的类库（更加方便）

  • 比如 Deque, PriorityQueue, Linkedlist, Stack等
  • 节省时间:帮助我们更专注于算法本身的思考,
  • 不需要考虑实现这些数据结构

去大厂做一名前端的网络工程师，必须用

熟练的 javascript刷题；

周一到周五 ：每晚分配2个小时，如工作日时间不够，多的留点时间到周末；

根据刷题速度，计算出三个月内，自己一共能做多少题；

按照力扣题目分类做题

• 树→图论→递归、回溯→DFS、BFS→动态规划→字符串和数组

  图论(树的一种扩展)

分类刷题的好处

• 能有效巩固知识点

• 帮助整理解题思路和归纳方法

• 有效提高解题速度

1.leetcode两个数的和

给出结果，找到数组中等于结果的 数组的下标

'use strict';
var v = "Hi! I'm a strict mode script!";
var twoSum = function(nums, target) {
  var a = [];
  for (var i = 0, len = nums.length; i < len; i++) {
    var tmp = target - nums[i];
    if (a[tmp] !== undefined) return [a[tmp], i];
    a[nums[i]] = i;
  }
};

2.两数相加-讲

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807

var addTwoNumbers = function(l1, l2) {
    var add = 0
        , ans
        , head;

//这个写法很不错

    while(l1 || l2) {
        var a = l1 ? l1.val : 0
            , b = l2 ? l2.val : 0;

        var sum = a + b + add;
        add = ~~(sum / 10);

        var node = new ListNode(sum % 10);

        if (!ans)
            ans = head = node;
        else {
            head.next = node;
            head = node;
        }

        if (l1)
            l1 = l1.next;
        if (l2)
            l2 = l2.next;
    }

    if (add) {
        var node = new ListNode(add);
        head.next = node;
        head = node;
    }

    return ans;
};

var x = -4.7
var y = 5.9
console.log(~~x,~~y);

14

var longestCommonPrefix = function(strs) {
    var a = strs[0]
    var  b= ""
    // if(!strs.length) return b;
    if(strs.length ==0  ){
        return ""
    }
    // if(a==""  || strs.length ==1 ) return a 
    //牛逼的报错，爸爸看不懂；TypeError：无法读取属性长度
    for(var  i = 0; i < a.length;i++) {
        for (var j=0;j<strs.length;j++){
            if( a[i] != strs[j][i] ){
                // console.log("Ff");
                return b
            }
        }
        b+=a[i]
    }
    return b
};

console.log(longestCommonPrefix(["flower","flow","flight"])) //fl
console.log(longestCommonPrefix(["dog","racecar","car"])) //""
console.log(longestCommonPrefix([";"]))  //;
console.log(longestCommonPrefix(["",""])) // 
console.log(longestCommonPrefix(["","",""])) // und
console.log(longestCommonPrefix(["aa","aa","aa"])) //aa
console.log(longestCommonPrefix(["cd","c"])) //c
console.log(longestCommonPrefix(["cccf","ccc"])) //un//undefined





var longestCommonPrefix = function(strs) {
  let re = '';
  if(!strs.length) return re;
  for(let j = 0; j < strs[0].length; j++) {
    for(let i = 1; i < strs.length; i++) {
      if(strs[i][j] != strs[0][j]) {
        return re;
      }
    }
    re += strs[0][j];
  }
  return re;
};

9. 回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true

示例 2:

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

// console.time()
// function cr(){
// 	var j=1 
// 	var i=0
// 	if (num[i]>num[j]) {
// 		num[j] ^= num[i],num[i] ^= num[j],num[j] ^= num[i]
// 	}
//     for(var j=1; j< num.length;j++){
//       if(num[j-1] > num[j]  ){
//       	for(var i=0;i<j;i++ ){
//       		if (num[i]< num[j] && num[i+1]>num[j]) {
//       			num[i+1] ^= num[j], num[j] ^= num[i+1], num[i+1] ^= num[j] 
//       		}
//       	}
//       }
// 	}
// 	return num
// }
// var num =  [5,2,8,3,7,9,4]
// console.log(cr(num))
// console.timeEnd()
// 插入排序

// console.time()
// 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;
// }

// console.log(insertionSort([5,2,8,3,7,9,4]))

// console.timeEnd()
// [ 2, 3, 4, 5, 7, 8, 9 ]
// default: 3.873ms
// [Finished in 0.1s]


--------------------------------------------------------------------------------------------

var isPalindrome = function(x) {
    
   if(x<0){
       // return false
   }
   // console.log("sd")

    var x= String(x)
    if(x%2==1){
        //奇数
        for (var i = 0; i<(x.length-1)/2;i++){
        if (x[i] != x[x.length - i-1]){
            console.log('ddd')
            return false

        }
    }
     return true
    }else{
        //偶数
        for (var i = 0; i<x.length/2;i++){
        if (x[i] != x[x.length - i-1]){
            // console.log('ddd')
            return false

        }
    }
     return true
    }
   
};



console.log(isPalindrome(121))
//执行结果：
// 通过
// 显示详情
// 执行用时 :228 ms, 在所有 javascript 提交中击败了87.40%的用户
// 内存消耗 :45.2 MB, 在所有 javascript 提交中击败了81.02%的用户

26-删除排序数组中的重复项

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:
给定数组 nums = [1,1,2], 
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 
你不需要考虑数组中超出新长度后面的元素。

示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。

js

执行用时 :96 ms, 在所有 javascript 提交中击败了84.15%的用户
内存消耗 :37.3 MB, 在所有 javascript 提交中击败了30.30%的用户


var removeDuplicates = function (nums) {
    var cur = nums[0];
    for (var i = 1; i < nums.length;) {
        if (nums[i] === cur){
            nums.splice(i, 1);
        }
        else
            cur = nums[i++];
    }
    return nums.length
};




执行用时 :88 ms, 在所有 javascript 提交中击败了91.32%的用户
内存消耗 :36.6 MB, 在所有 javascript 提交中击败了82.94%的用户

var removeDuplicates = function (nums) {
    var len = 1;
    for (var i = 1; i < nums.length; i++)
        if (nums[i] != nums[i-1]) nums[len++] = nums[i];
            
    return len
};

输出：
// 必须是排好序的
nums = [0,0,1,2,2,3,3,3,4,4,4,4]
console.log(removeDuplicates(nums));

python

执行用时 :96 ms, 在所有 python 提交中击败了50.64%的用户
内存消耗 :13.5 MB, 在所有 python 提交中击败了28.79%的用户

class Solution:
	#定义一个类
	#编写函数
    def removeDuplicates(self, nums):
    	# : List[int]) -> int:
        pre,cur=0,1
        while cur<len(nums):       
            if nums[pre]==nums[cur]:
        # pop() 函数用于移除列表中的一个元素（默认最后一个元素），
        # 并且返回该元素的值。
                nums.pop(cur)
            else:
                pre,cur=pre+1,cur+1
        return len(nums)

a = Solution()
nums = [0,0,1,1,1,2,2,3,3,4]
b=a.removeDuplicates(nums)
print(b)

Ruby

def remove_duplicates(nums)
    return nums.length if nums.length < 2
    (nums.length-1).downto(0) do |index|
        # 从后往前遍历数据，如果当前index的值与nums.index(num)(此num值在数组中第一次出现的index)不等，则删除此index的值
        nums.delete_at(index) if nums.index(nums[index]) != index
    end
    nums.length
end

c

int removeDuplicates(int *nums,int numsSize){
    if (numsSize==0) return false;
    //k为计数器，计算新表里面不相同元素的个数
    int k=1;
    int p=nums[0];
    for (int i=1;i<numsSize;i++){
        if (nums[i]!=p){
            nums[k++]=nums[i];
            p=nums[i];
        }
    }
    return k;
}

67-JavaScript 二进制求和

JavaScript 二进制求和

解一（伪）：

转换为十进制进行计算，再将结果转换为二进制返回。会产生溢出

var addBinary = function(a, b) {
    a = parseInt(a,2);
    b = parseInt(b,2);
    return (a+b).toString(2)
};


解二：

将字符串每一位分割入数组保存，先将a和b数组长度补齐为二者最大长度+1，多出来的一位用来放置进位。计算过程就和小时候笔算十进制一样，本位相加，超出则进位。最后若首位为0则削去首位。

var addBinary = function(a, b) {
    function add(x,y) {
        if (x) return (x+y);
        else return y
    }
    a = a.split('').map(Number);
    b = b.split('').map(Number);
    var len = Math.max(a.length,b.length)+1;
    while(a.length!==len) a.unshift(0);
    while(b.length!==len) b.unshift(0);
    var c = [];
    for (var i=len-1;i>=0;i--){
        c[i] = add(c[i],a[i]+b[i]);
        if (c[i]>1) {
            c[i-1]=add(c[i-1],1);
            c[i]=c[i]-2;
        }
    }
    if (!c[0]) c.shift();
    c = c.join('');
    return c;
};


解三：
解二的速度很快，但内存消耗很大。解三在解二的基础上省略了一开始字符串和数组的转换，也利用JavaScript弱类型的特性省去了数字和字符的转换。

var addBinary = function (a, b) {
    var len = Math.max(a.length, b.length) + 1;
    while (a.length !== len) a = '0' + a;
    while (b.length !== len) b = '0' + b;
    var c = [];
    for (var i = len - 1; i >= 0; i--) {
        c[i] = c[i] ? c[i] + (a[i] - 0) + (b[i] - 0) : (a[i] - 0) + (b[i] - 0);
        if (c[i] > 1) {
            c[i - 1] = c[i - 1] ? c[i - 1] + 1 : 1;
            c[i] = c[i] - 2;
        }
    }
    if (!c[0]) c.shift();
    return c.join('');
};

70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
       var a= 0;
        var b=1;
    for(var i = 0;i<n;i++){
       tmp= b+a
        a = b
        b = tmp
       
        
    }
    return tmp
    
};

// console.log(clibStairs(5))

// var climbStairs = function(n) {
//     if(n==1){
//         return 1
//         }
//     if(n==2){
//         return 2 
//     }
//     return climbStairs(n-1)+climbStairs(n-2)
// };

118. 杨辉三角-|

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 5
输出:
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

代码

var generate = function(numRows) {
    var a = []
    if(numRows == 0) return a= []
    for (var i = 0;i<numRows;i++){
        a[i]=[]
        a[i][0] = 1 
        a[i][i] =1
        for(var j=1;j<i;j++){
              a[i][j] = a[i-1][j-1]+a[i-1][j]
            // console.log(a)
        }
    }
    return a
};


console.log(generate(0))
console.log(generate(1))
console.log(generate(2))
console.log(generate(3))
console.log(generate(4))

[]
[ [ 1 ] ]
[ [ 1 ], [ 1, 1 ] ]
[ [ 1 ], [ 1, 1 ], [ 1, 2, 1 ] ]
[ [ 1 ], [ 1, 1 ], [ 1, 2, 1 ], [ 1, 3, 3, 1 ] ]

执行用时 :72 ms, 在所有 javascript 提交中击败了60.33%的用户
内存消耗 :33.7 MB, 在所有 javascript 提交中击败了49.50%的用户

189. 旋转数组-|

Do not return anything, modify nums in-place instead.

不返回任何内容，而是就地修改nums。

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

示例 2:

输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释: 
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]

说明:

• 尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
• 要求使用空间复杂度为 O(1) 的 原地 算法。

var rotate = function(nums, k) {
     nums.unshift(...nums.splice(nums.length - k, k))
}

for (var i =0;i<k;i++) {
        let b = nums.pop();
        nums.unshift(b);
    }
    return nums;

python

左旋
def rotate(self, nums, k):
            n = len(nums)
            k = k%n
            if k == 0:
                return 
            count = n-k
            tmp = nums[:]
            for i in range(n):
                nums[i] = tmp[(i+count)%n]
右旋
        def rotate(self, nums, k):
            n = len(nums)
            k = k%n
            if k == 0:
                return
            tmp = nums[:]
            for i in range(n):
                nums[(i+k)%n] = tmp[i]
翻转
    def rotate(self, nums, k):
        n = len(nums)
        k %= n
        self.func(nums, 0, n-1)
        self.func(nums, 0, k-1)
        self.func(nums, k, n-1)
    
    def func(self, nums, start, end):
        while start < end:
            tmp = nums[start]
            nums[start] = nums[end]
            nums[end] = tmp
            start += 1
            end -= 1
插入
    def rotate(self, nums: List[int], k: int) -> None:
        k %= len(nums)
        for i in range(k):
            x = nums.pop()
            nums.insert(0,x)
pythonic
  def rotate(self, nums, k):
        n = len(nums)
        k = k%n
        if k == 0:
            return
        # 注意：这儿是nums[:],而不是nums
        nums[:] = nums[n-k:]+nums[0:n-k]
python效率高
          nums[:]=nums[-(k%len(nums)):]+nums[:-(k%len(nums))]
python 利用语言特性偷懒  
            for i in range(k):
            nums.insert(0, nums.pop()) 

javascript

 我觉得是很简单的方法了，JavaScript版， 为啥在leetcode通过不了，我在chrome运行正常呀 ？？？

return [...nums.splice(-k, k), ...nums];


js
var rotate = function(nums, k) {
  for (let i = 0;i < k; i++) {
    nums.unshift(nums.pop())
  }
}

tong过 48
var rotate = function(nums, k) {
    for(let i=0;i<k;i++) {
        nums.unshift(nums.pop())
    }
    return nums;
};

//执行用时 :68 ms, 在所有 javascript 提交中击败了98.09%的用户  nb
var rotate = function(nums, k) {
    // 方法一
    /*
     * 1. 截取nums倒数k位
     * 2. 拼接
     */
     nums.unshift(...nums.splice(nums.length - k, k))
}

//重复k次，把nums的最后一位删除，并把最后一位加到nums左边。 keyi 
var rotate = function (nums, k) {
    while (k-- != 0) {
        nums.unshift(nums.pop());
    }
};


//又通过了， 应该是只能操作原数组
var rotate = function (nums, k) {
    if (k <= 0) {
        return nums;
    };
    for (var i =0;i<k;i++) {

        let b = nums.pop();
        nums.unshift(b);
    }
    return nums;
};
//js版本，这样竟然说不行，why?
var rotate = function(nums, k) {
    
	let arr = nums.slice(nums.length-k);
	return arr.concat(nums.slice(0,nums.length-k));
};


/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
   // var a =(nums.slice(nums.length-k))
   // var b= (nums.slice(0,nums.length-k))
        // return  a.concat(b)
    
    
//     if(nums.length<2 || k===0){
//         return ;
//     }
//     k =k % nums.length
//     const cut =nums.length-k,k)
    
    
    var rotate = function(nums, k) {
  if (nums.length < 2 || k === 0) {
    return;
  }
  k = k % nums.length;
  const cut = nums.splice(nums.length - k, k);
  nums.unshift(...cut);
};

    
};

java

链表连接,击败100%,bushi java
class Solution {
public:
	void rotate(vector<int>& nums, int k) {
                if(k>nums.size()) k=k%nums.size();
		nums.insert(nums.begin(), nums.end() - k,nums.end());
		nums.erase(nums.end() - k, nums.end());
	}
};



import java.util.Arrays;

class Solution {
    /**
     * 双重循环
     * 时间复杂度：O(kn)
     * 空间复杂度：O(1)
     */
    public void rotate_1(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        for (int i = 0; i < k; i++) {
            int temp = nums[n - 1];
            for (int j = n - 1; j > 0; j--) {
                nums[j] = nums[j - 1];
            }
            nums[0] = temp;
        }
    }

    /**
     * 翻转
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)
     */
    public void rotate_2(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        reverse(nums, 0, n - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, n - 1);
    }


    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start++] = nums[end];
            nums[end--] = temp;
        }
    }

    /**
     * 循环交换
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)
     */
    public void rotate_3(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        // 第一次交换完毕后，前 k 位数字位置正确，后 n-k 位数字中最后 k 位数字顺序错误，继续交换
        for (int start = 0; start < nums.length && k != 0; n -= k, start += k, k %= n) {
            for (int i = 0; i < k; i++) {
                swap(nums, start + i, nums.length - k + i);
            }
        }
    }

    /**
     * 递归交换
     * 时间复杂度：O(n)
     * 空间复杂度：O(n/k)
     */
    public void rotate(int[] nums, int k) {
        // 原理同上
        recursiveSwap(nums, k, 0, nums.length);
    }

    private void recursiveSwap(int[] nums, int k, int start, int length) {
        k %= length;
        if (k != 0) {
            for (int i = 0; i < k; i++) {
                swap(nums, start + i, nums.length - k + i);
            }
            recursiveSwap(nums, k, start + k, length - k);
        }
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

409. 最长回文串|

给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。

在构造过程中，请注意区分大小写。比如 "Aa" 不能当做一个回文字符串。

注意: 假设字符串的长度不会超过 1010。

示例 1:

输入:
"abccccdd"

输出:
7

解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7

执行用时 :80 ms, 在所有 javascript 提交中击败了72.56%的用户

内存消耗 :35.1 MB, 在所有 javascript 提交中击败了61.43%的用户

/**
 * @param {string} s
 * @return {number}
 */
var longestPalindrome = function(s) {
     var c = 0 
     var b = 0
     var d= []
   // console.log('dsd')
    for(var i = 0; i<s.length;i++){
        // js判断一个元素是否在数组中,不在则添加
        if(!d.includes(s[i])){ 
             d += s[i] 
             // console.log(d)
             var a=1
             for (var j =i+1; j<s.length;j++){
                 if(s[i]==s[j]  ){
                    a+=1
                }
                } 
                // console.log('er')
                 if(a == 1 ){
                 b = 1
             }else if(a%2 == 1 ){
                 c += (a-1)
                 b=1
             }else{
                c+=a
             }
}
        }
         return  c+b
};  

default: 0.170ms
console.log(longestPalindrome("abccccdd"))

403.青蛙过河-|||

一只青蛙想要过河。 假定河流被等分为 x 个单元格，并且在每一个单元格内都有可能放有一石子（也有可能没有）。 青蛙可以跳上石头，但是不可以跳入水中。

给定石子的位置列表（用单元格序号升序表示）， 请判定青蛙能否成功过河（即能否在最后一步跳至最后一个石子上）。 开始时， 青蛙默认已站在第一个石子上，并可以假定它第一步只能跳跃一个单位（即只能从单元格1跳至单元格2）。

如果青蛙上一步跳跃了 k 个单位，那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1个单位。 另请注意，青蛙只能向前方（终点的方向）跳跃。

请注意：

• 石子的数量 ≥ 2 且 < 1100；
• 每一个石子的位置序号都是一个非负整数，且其 < 231；
• 第一个石子的位置永远是0。

示例 1:

[0,1,3,5,6,8,12,17]

总共有8个石子。
第一个石子处于序号为0的单元格的位置, 第二个石子处于序号为1的单元格的位置,
第三个石子在序号为3的单元格的位置， 以此定义整个数组...
最后一个石子处于序号为17的单元格的位置。

返回 true。即青蛙可以成功过河，按照如下方案跳跃： 
跳1个单位到第2块石子, 然后跳2个单位到第3块石子, 接着 
跳2个单位到第4块石子, 然后跳3个单位到第6块石子, 
跳4个单位到第7块石子, 最后，跳5个单位到第8个石子（即最后一块石子）。

示例 2:

[0,1,2,3,4,8,9,11]

返回 false。青蛙没有办法过河。 
这是因为第5和第6个石子之间的间距太大，没有可选的方案供青蛙跳跃过去。

941. 有效的山脉数组

941. Valid Mountain Array

给定一个整数数组 A，如果它是有效的山脉数组就返回 true，否则返回 false。

让我们回顾一下，如果 A 满足下述条件，那么它是一个山脉数组：

A.length >= 3
There exists some i with 0 < i < A.length - 1 such that:
A[0] < A[1] < ... A[i-1] < A[i]
A[i] > A[i+1] > ... > A[A.length - 1]

Example 1:

Input: [2,1]
Output: false

Example 2:

Input: [3,5,5]
Output: false

Example 3:

Input: [0,3,2,1]
Output: true

Note:

1. 0 <= A.length <= 10000
2. 0 <= A[i] <= 10000

1-有效的回旋镖c#

题目：有效的回旋镖(Valid Boomerang)

题意：

回旋镖定义为一组三个点，这些点各不相同且不在一条直线上。 给出平面上三个点组成的列表，判断这些点是否可以构成回旋镖。

思路：

题目说是回旋镖，其实就是三角形。只要能判断三点不共线就可以。

方法一：简单的想法可以用斜率和截距的方法，判断三点共线。

缺点：要用到除法，可能有精度问题，而且要考虑和坐标轴平行的特殊情况。

方法二：利用三角形变长的性质，两边之和大于第三边。

缺点：也存在用开方的操作，可能有精度问题。

向量叉积后还是的向量，这个向量的长度是两个向量所组成平行四边形的面积。如果共线，这个值为0。

具体可以参考维基百科：(叉积)

https://zh.wikipedia.org/wiki/%E5%8F%89%E7%A7%AF

代码：

class Solution {
public:
    bool isBoomerang(vector<vector<int>>& points) {
        int x1=points[0][0],y1=points[0][1];
        int x2=points[1][0],y2=points[1][1];
        int x3=points[2][0],y3=points[2][1];

        int cross = (y3-y1)*(x2-x1) - (y2-y1)*(x3-x1);
        return cross != 0;
    }
};

2-从二叉搜索树到更大和树

从二叉搜索树到更大和树(Binary Search Tree to Greater Sum Tree)

题意：

修改树的每个节点的值，为访问的所有节点的和，包括当前节点。 访问的次序是先访问右子树，再访问根节点，再访问左子树。

思路：

代码比较简单，递归实现。

代码：

class Solution {
public:
    int ans = 0;
    TreeNode* bstToGst(TreeNode* root) {
        if(root==nullptr)
            return root;
        bstToGst(root->right);
        ans+=root->val;
        root->val=ans;
        bstToGst(root->left);
        return root;
    }
};

3-多边形三角剖分的最低得分

题目：多边形三角剖分的最低得分(Minimum Score Triangulation of Polygon)

题意：

想象一个凸 N 边多边形，其顶点按顺时针顺序依次标记为 A[0], A[i], …, A[N-1]。

假设您将多边形剖分为 N-2 个三角形。对于每个三角形，该三角形的值是顶点标记的乘积，三角剖分的分数是进行三角剖分后所有 N-2 个三角形的值之和。

返回多边形进行三角剖分后可以得到的最低分。

思路：

选定凸多边形的一条边为底（A[0]A[N-1]组成的线段），和A[i]为顶点，可以把凸多边形分为三部分，左侧A[0]A[1]…A[i]组成的凸多边形，右侧A[i]A[i+1]…A[N-1]组成的凸多边形，还有A[0]A[i]A[N-1]组成的三角形。

两个凸多边形还可以再递归分解，最后比较出最优解。递归算过的形状不用重复计算，可以用记忆化搜索，记录中间结果。

如果凸多边形只有两个点，那么组成不了三角形，可以直接返回权值为0。

递推公式为：

设w(i,k,j)为i,j,k三个点组成的三角形的权值。

v[i][j]=0 (当i+1==j时)

v[i][j]=v[i][k]+v[k][j]+w(i,k,j)

（当i + 1 < j时, i < k < j)

代码：

class Solution {
public:
    int memo[51][51]={0};
    inline int w(int i, int j, int k, vector<int>& A)
    {
        return A[i]*A[j]*A[k];
    }
    int dfs(int i, int j, vector<int>& A)
    {
        if(i==j-1)
            return 0;

        if(memo[i][j]!=0)
            return memo[i][j];

        memo[i][j]=INT_MAX;
        for(int k = i+1; k < j; ++k)
        {
            int ans = dfs(i, k, A) + w(i, k, j, A) + dfs(k, j, A);
            memo[i][j] = min(ans, memo[i][j]);
        }
        return memo[i][j];
    }
    int minScoreTriangulation(vector<int>& A) {
        int n = A.size();

        return dfs(0, n-1, A);

    }
};

4-移动石子直到连续 II

题目：移动石子直到连续 II(Moving Stones Until Consecutive II)

在数轴上摆放了n个石子，石子位置都是整数，并且不能重叠。游戏规则是：每个回合，将一颗端点石子拿起并移动到一个未占用的位置，使得该石子不再是一颗端点石子。无法移动时游戏停止。

问最小和最大移动次数分别是多少。

思路：

题目是上周第一题的扩展，但是有点不同。

由题意可知，每进行一轮操作，石子的左右端点的距离会缩短，一轮一轮收敛。最后会石子都紧邻游戏结束。

举个例子：

初始时有8颗石子，在数轴上的有石子的刻度为：

4，6，8，9，15，16，19，20

最大值求解方法：

石子可以放置的空间，等于左右两端石子之间的未占用位置。在例子中，一共有20-4+1-8个位置。

石子覆盖的线段长度是20-4个，加上一个端点的位置即20-4+1，再减去已经占用的8个位置。

用公式表示为

s1=stones[n-1]-stones[0]+1-n。

但是第一次移动的左端点或右端点的石子后，这个移动的石子和它相邻的那颗石子之间的空间，后面就不能被放置了，因为与他相邻的那个点变为端点，他们之间的位置不可以被放置了。

例如第一步移动了4，那么5这个位置就不可能放置石子了。所以要计算不能被访问的空间

s2=min(stones[n-1]-stones[n-2]-1, stones[1]-stones[0] -1)。

最大值为s1-s2。因为在后面的步骤里，我们都可以做出策略，让每一轮左右端点的差值只减1。

最小值求解方法：

如果最后游戏结束，那么一定有n个连续坐标摆满了石子。如果我们要移动最少，必定要找一个石子序列，使得在n大小连续的坐标内，初始时有最多的石子。

设想有个尺子，上面有n个刻度点，我们用这个尺子在石子从最左边到最右边移动，每动一次都查看下在尺子范围内有m个石子，那么要使这个区间填满，就需要移动n-m次。

只要在尺子外部有石子，就有策略填满尺子内的。

这些次数中最小的就为虽少次数。

但是有一种特例：

1，2，3，4，7

这种1-4是最好的序列，但是7不能移动到端点，只能1先移动到6，然后7移动到5解决，这种情况要用2步。就是尺子内的石子都是连续的，中间没空洞，只在边上有空，要用2次。

代码：

class Solution {
public:
    vector<int> numMovesStonesII(vector<int>& stones) {
        sort(stones.begin(),stones.end());
        int n = stones.size();
        int mx = stones[n - 1] - stones[0] + 1 - n;
        mx -= min(stones[n-1]-stones[n-2] - 1, stones[1]-stones[0] -1);
        int mi = mx;
        int i = 0;
        int j = 0;
        for(i = 0; i < n; ++i)
        {
            while(j + 1 < n && stones[j + 1] - stones[i] + 1 <= n)
                ++j;
            int cost = n - (j - i + 1);
            if(j - i + 1 == n - 1 && stones[j] - stones[i] + 1 == n - 1)
                cost = 2;
            mi = min(mi, cost);
        }
        return vector<int>{mi, mx};
    }
};

LCP 1. 猜数字

（对比两个列表数字相同）

小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？
输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。

 

示例 1：
输入：guess = [1,2,3], answer = [1,2,3]
输出：3
解释：小A 每次都猜对了。
 

示例 2：
输入：guess = [2,2,3], answer = [3,2,1]
输出：1
解释：小A 只猜对了第二次。
 

限制：
guess的长度 = 3
answer的长度 = 3
guess的元素取值为 {1, 2, 3} 之一。
answer的元素取值为 {1, 2, 3} 之一。

python语言

return sum(guess[i]==answer[i] for i in range(len(guess)))
return sum(map(lambda x, y: x == y, guess, answer))

我第一次写出来的leetcode；翻译的python列表推导式

/**
 * 这个是javascript
 * @param {number[]} guess
 * @param {number[]} answer
 * @return {number}
 */
var game = function(guess, answer) {
    var q=0
    for(i=0;i<guess.length;i++){
    guess[i]==answer[i]?q++:q
    }
    return q
};

### 简介

「力扣编辑器」本质上是一个特别的 Markdown 编辑器，之所以特别是因为她不仅支持了传统的 Markdown 语法，同时还支持力扣独有的特殊格式和功能。

---

### 支持语法

#### 标题

# heading 1
## heading 2
### heading 3
#### heading 4
##### heading 5
###### heading 6

---


#### 引用

> 在 `>` 后插入您所希望应用的内容。

---

#### 列表

> 无序列表

- 文本一
- 文本二
- 文本三

> 有序列表

1. 文本一
2. 文本二
3. 文本三

---

#### 文字变形

_斜体_
*斜体*
 
__粗体__
**粗体**

---

#### Latex

行内 Latex 支持：$O(n^2)$。

$$m \leq n,\  i < m \implies j = \frac{m+n+1}{2} - i > \frac{m+n+1}{2} - m \geq \frac{2m+1}{2} - m \geq 0$$

> 需要独行 Latex，请使用 `$$` 包围。

---

#### 代码

使用一段 `行内代码`。

> 代码片段

​```java
public class Main {
    public static void main(String[] args) {
        System.out.print("你好力扣");
    }
}
​```

> 组合代码模块

​```java [solution1-Java 答案]
public class Main {
    public static void main(String[] args) {
        System.out.print("你好力扣");
    }
}
​```
​```python [solution1-Python 答案]
print "你好力扣"
​```

---

#### 表格

名称 | 缩写
--- | ---
JavaScript | js
Python | py
C++ | cpp

> 使用冒号定义对齐方式

| 题号 | 标题 | 难易度 |
| :--- | ---:| :---: |
| 1 | 两数之和 | 简单 |
| 15 | 三数之和 | 中等 |
| 262 | 行程和用户 | 困难 |

---

#### 链接

[这是一个超级链接](https://leetcode-cn.com)

---

#### 图片

![力扣](https://pic.leetcode-cn.com/056dd17dd0506591d04525f015765ab749e9f9f19dcaf6e0dcae5d77057d2392-15@3x.png){:width=100}

> 使用传统 `![图片名称](图片地址)` Markdown 语法，或将图片直接拖拽到编辑器中进行上传。
>
> 可以在图片尾部添加 `{:width=宽度像素}` 限制图片宽度，或者 `{:height=高度像素}` 限制图片高度。

---

#### 视频

![力扣视频](562986b1-46d8-48ef-bac6-82685bcedcd8)


> 使用工具栏中「视频上传」工具进行上传，支持 m4v、mp4、mov、flv 等多种主流视频格式。
> 视频内容需要等待人工审核完成后才能执行播放，审核期间不影响内容发布。

---

### 结尾

为了让您的内容可以给大家带来最佳的阅读体验，我们推荐您遵循「[中文文案排版指北](https://github.com/sparanoid/chinese-copywriting-guidelines/blob/master/README.zh-CN.md)」。

更多 Markdown 语法，请查看 [官方文档](https://www.markdownguide.org/basic-syntax/)。

最后，感谢您抽空阅读本「力扣编辑器」使用说明，祝您创作愉快！

知识梳理

与或非

var  i = 1.4 //或者
if ( i>2 | i<1.5) {console.log("ehh ")}
if ( i>2 || i<1.5) {console.log("ehh ")}
var i=4 //非 not
if ( !!!(i>2 && i<1.5)) {console.log("ehhsaddsadsadsa ")}
if ( ~(i>2 && i<1.5)) {console.log("ehhsaddsadsadsa ")} 
if ( !(i>2 && i<1.5)) {console.log("ehhsaddsadsadsa ")}
console.log(~5)
    var i=4 //和
if ( i>2 && i<6) {console.log("ehh sd")}
if ( i>2 & i<6) {console.log("ehh sd")}

python的引用

#类 函数
class Solution:
	def rotate(self, nums:[1,2,3,3442,323,42,3,5], k: 3) -> None:
#	def rotate(self, nums, k) :
		for i in range(k):
			a=nums.pop()
			nums.insert(0,a)
		return nums
if __name__ == '__main__':
	print(Solution().rotate([12,232,2,4,4,],4))

Lintcode

皮棉代码 面试

https://www.lintcode.com/

位运算： 1、按位或|： 2、按位与&： 0&0=0 1&1=1 0&1=0 1&0=0 3、按位异或^ 0^0=0 1^1=0 0^1=1 1^0=1 步骤1：a^b异或运算，忽略进位 步骤2：a&b与运算，左移一位 步骤3：相加

1807

ACM竞赛

ACM竞赛是由ACM(AssociationforComputingMachinery，美国计算机协会)组织的 ACM竞赛年度性竞赛，始于1970年，是全球大学生计算机程序能力竞赛活动中最有影响的一项赛事，是全球历史最悠久、规模最大且最负盛名的程序设计竞赛。竞赛提倡创新和团队协作，鼓励学生在构建全新的软件程序时尽情发挥创意，帮助学生检验自己在强压力下的工作能力。是世界各地计算机程序设计者大显身手的舞台，也是世界一流大学展现教育成果的最佳窗口。

• 中文名：美国计算机协会
• 外文名：AssociationforComputingMachinery
• 简称：ACM
• 始于：1970年

POJ是“北京大学程序在线评测系统”

POJ是“北京大学程序在线评测系统”（PekingUniversityOnlineJudge）的缩写，是个提供编程题目的网站，兼容Pascal、C、C++、Java、Fortran等多种语言。

• 中文名

  北京大学程序在线评测系统

• 外文名：Peking （北京的旧称）University （大学）Online Judge 北京大学在线法官

• 简称：POJ

• 类别：提供编程题目的网站

• - Welcome To PKU JudgeOnline 北京大学的Online Judge。POJ上面的题目有点老了，但好处是做的人多，经典算法题多，解题报告也多，适合上手。

• （三）稿费

  1. A类题：难度相近于NOIP，或ACM分区赛较容易的题目，稿费300元；
  2. B类题：难度相近于NOI，或ACM分区赛较困难的题目，稿费600元；
  3. 无论哪类题，如同时提供中英文版，且题解格式规范描述准确，有必要的图表、公式的，额外稿费100元。

  在一次挑战赛中，A类题与B类题数量大致相当。题目类别无需在投稿时注明，而将在录用后由POJ团队审核认定。

hud杭州电子科技大学

国籍Nationality 
等级266386		Rank 266386
提交的问题0	Problems Submitted 0
解决的问题0		Problems Solved 0
提交0	Submissions 0
已接受0		Accepted 0

参考文献

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/guess-numbers

26. 删除排序数组中的重复项
https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/description/

比赛的地址 Weekly Contest 135
https://leetcode-cn.com/contest/weekly-contest-135



JavaScript数据结构与算法（链表）
https://juejin.im/post/5b485783e51d451926483773

JS中的算法与数据结构——链表(Linked-list)
https://juejin.im/entry/59cb70995188256aa423b680


移动石子直到连续 II(Moving Stones Until Consecutive II)
https://leetcode-cn.com/contest/weekly-contest-135/problems/moving-stones-until-consecutive-ii/

Linked List 常见问题总结(微信号)
https://mp.weixin.qq.com/s/ZtF0fkQa8wZGXmeRDIvHtg

poj  北京大学程序在线评测系统
http://poj.org/