最全名企笔算法题

·给一个由数字组成的字符串。写一个函数求出其可能恢复为的所有IP地址。

格式：

第一行输入一个由数字组成的字符串 T，最后由这个字符串所能形成的所有的 IP 地址的数组。

样例输入

T = "25525511135"

样例输出

[

 "255.255.11.135"，

 "255.255.111.35"

]

 

 

 

 

 

 

·给定 n 个不同的正整数，整数 k（k< = n）以及一个目标数字。在这 n 个数里面找出 k 个数，使得这 k 个数的和等于目标数字，写一个函数实现找到不同的方案的数量。

格式：

输入第一行输入一个整数数组，第二行输入一个整数 k ，第三行输入一个整数 target最后输出使得数组中不同的 k 个数的和为 target 的种类。

样例输入

[ 1，2，3，4 ]

k = 2

target = 5

样例输出

2

 

 

 

 

 

 

 

·给你一个没有排序的数组，请将原数组就地重新排列满足如下性质：

nums[0] <= nums[1] >= nums[2] <= nums[3]....

请写一个函数实现此排序功能。 

 

注意事项：

请就地排序数组，也就是不需要额外数组

 

格式：

输入第一行输入一个带排序的数组nums，最后输出按照要求排序后的数组序列。

 

样例输入

nums = [ 3，5，2，1，6，4 ] 

样例输出

[ 1，6，2，5，3，4 ]

 

 

 

 

 

 

 

 

 

·给一个二维的矩阵，包含 'X' 和 'O'，写一个函数找到找到所有被 'X' 围绕的区域，并用 'X' 填充满。

格式：

第一行输入一个由 ‘X’ 和 ‘O’ 的数组，最后输出用 ‘X’ 填充完的数组。

样例输入

X X X X

X O O X

X X O X

X O X X

样例输出

X X X X

X X X X

X X X X

X O X X

 

 

 

 

 

 

·给你两个字符串 S 和 T, 判断他们是否只差一步编辑。即两个字符串是否只有一个字符不同。编写一个函数实现此功能。

格式：

输入第一行输入一个字符串 S，第二行输入一个字符串 T，最后输出是否可以只差一步编辑，如果可以输出 true，如果不可以则输出 false。

样例输入

S = "ade"

T = "aDe"

样例输出

True

 

 

 

 

·写一个函数找出一个序列中乘积最大的连续子序列，其中序列中至少包含一个数）。

格式：

第一行输入一个数组，最后依次输出最大乘积的子序列及其乘积的大小。

样例输入

[ 2，3，-2，4 ]

样例输出

[ 2，3 ]

6

 

 

 

 

 

 

·给一个非负整数 n, 用单词打印数字，写一个方法输出用来表示的数字的单词。

格式：

第一行输入一个非负整数，最后用单词打印出数字。

样例输入

n = 125

样例输出

one hundred twenty five

 

 

 

 

 

 

 

 

·给出一个字符串 s 和一个词典，写一个函数判断字符串 s 是否可以被空格切分成一个或多个出现在字典中的单词。

格式：

输入行输入一个字符串 s 和一个字典 dict，最后输出字符串 s 是否可以被空格切分成一个或多个出现在字典中的单词。如果可以则输出 true，不可以则输出 false。

样例输入

s = "lintcode"

dict = [ "lint"，"code" ]

样例输出

True

 

 

 

 

·给一个整数数组，写一个函数实现在数组中找到第 k 大的元素。

注意事项：

你可以交换数组中的元素的位置。

格式：

输入依次输入一个整数数组和一个整数 k ，最后输出数组中第 k 大的元素。

样例输入

[ 9，3，2，6，11]

k = 1

样例输出

11

 

 

 

 

 

 

·给定 n 和 k，写一个函数，求123..n 组成的排列中的第 k 个排列。

注意事项：1 ≤ n ≤ 9

格式：

第一行输入一个整数 n，第二行输入一个整数 k，最后输出 n 的第k 个全排列。

样例输入

n = 3

k = 4

样例输出

231

 

 

 

 

 

·给出一个整数数组，写一个函数将数组堆化。堆化操作就是把它变成一个最小堆数组。对于堆数组A，A[0] 是堆的根，并对于每个 A[i]，A [i * 2 + 1] 是 A[i] 的左儿子并且 A[i * 2 + 2] 是A[i] 的右儿子。

说明：

什么是堆？

 

 

 

 

 

·堆是一种数据结构，它通常有三种方法：push， pop 和top。其中，“push” 添加新的元素进入堆，“pop” 删除堆中最小/最大元素，“top” 返回堆中最小/最大元素。

什么是堆化？

 

 

·把一个无序整数数组变成一个堆数组。如果是最小堆，每个元素 A[i]，我们将得到 A[i * 2 + 1] >= A[i] 和 A[i * 2 + 2] >= A[i]

如果有很多种堆化的结果？返回其中任何一个。

格式：

输入行输入一个整数数组，最后输出经过堆化后的数组。

样例输入

[ 3，2，1，4，5]

样例输出

[ 1，2，3，4，5]

 

 

 

 

 

 

·给定一个整数矩阵，请编写一个函数找出一个子矩阵，使得其数字之和等于0。输出答案时，请返回左上数字和右下数字的坐标。

格式：

输入每一行输入一个 二维整数数组戴代表一个矩阵，输出每一行输出使得子矩阵数字之和为 0 的左上数字和右下数字的坐标组成的数组。

样例输入

[

  [ 1，5，7]，

  [ 3，7，-8]，

  [ 4，-8，9]，

]

样例输出

[ (1，1)，(2，2) ]

 

 

 

 

 

·给出一个可能包含重复的整数数组，和一个大小为 k 的滑动窗口。从左到右在数组中滑动这个窗口，写一个函数找到数组中每个窗口内的最大值。

格式：

输入行依次输入一个整数数组 num 和一个表示滑动窗口大小的整数 k ，最后输出每一个滑动窗口内的最大值的数组。

样例输入

num = [ 1，2，7，7，8]

k = 3

样例输出

[ 7，7，8]

 

 

 

 

·在一条环路上有 N 个加油站，其中第 i 个加油站有汽油gas[ i ]，并且从第 i 个加油站前往第 i+1 个加油站需要消耗汽油cost[ i ]。

你有一辆油箱容量无限大的汽车，现在要从某一个加油站出发绕环路一周，一开始油箱为空。

写一个函数求可环绕环路一周时出发的加油站的编号，若不存在环绕一周的方案，则返回-1。

注意事项：

1、数据保证答案唯一。

2、O(n)时间和O(1)额外空间

 

格式：

输入行依次输入一个表示每个加油站的汽油的容量的数组 gas 和一个表示加油站之间耗油量的数组 cost ，最后输出可环绕一周的加油站的编号，如果不存在则返回 -1。

样例输入

gas = [ 1，1，3，1 ]

cost = [ 2，2，1，1 ]

样例输出

2   

 

 

 

 

 

·给定一个m×n矩阵，如果一个元素是0，则将其所在行和列全部元素变成0。并要求需要在原矩阵上完成操作。写一个函数实现次功能。

格式：

输入行依次输入一个初试矩阵，最后输出经过转换后的数组。

样例输入

[

  [ 1，2 ]，

  [ 0，3 ]

]

样例输出

[

  [ 0，2 ]，

  [ 0，0 ]

]

 

 

 

 

·给定一个单链表和数值 x，写一个函数来划分链表，使得所有小于 x 的节点排在大于等于 x 的节点之前。你应该保留两部分内链表节点原有的相对顺序。

格式：

输入第一行输入一个链表，第二行输入一个整数 x ，最后输出划分后的链表。

样例输入

1 -> 4 -> 3 -> 2 ->5 -> 2 -> null

x = 3

样例输出

1 -> 2 -> 2 -> 4 ->3 -> 5 -> null

 

 

 

 

 

 

 

 

·请写一个函数实现在 O(n log n) 时间复杂度和常数级的空间复杂度下给链表排序。

格式：

输入第一行输入一个链表，最后输入按升序排列后的链表。

样例输入

1 -> 3 -> 2 -> null

样例输出

1 -> 2 -> 3 -> null

 

 

 

 

 

 

 

·请写一个程序，找到两个单链表最开始的交叉节点。

注意事项

1、如果两个链表没有交叉，返回null。

2、在返回结果后，两个链表仍须保持原有的结构。

3、可假定整个链表结构中没有循环。

格式：

第一行输入两个链表 A 和 B，最后输出两个链表的交叉节点。

样例输入

A:         a1 → a2

                           ↘

                              c1 → c2 → c3

                           ↗            

B:     b1 → b2 →b3

样例输出

c1

 

 

 

 

 

 

 

·给出一个字符串数组 S，写一个函数找到其中所有的乱序字符串（Anagram）。如果一个字符串是乱序字符串，那么它存在一个字母集合相同，但顺序不同的字符串也在S中。

注意事项：

所有的字符串都只包含小写字母

格式：

输入行输入一个字符数组 S，最后输出其中的乱序字符串。

样例输入

S = [ "lint"，"intl"，"inlt"，"code" ]

样例输出

[ "lint"，"inlt"，"intl" ]

 

 

 

 

 

 

 

 

·给定一个包含 m x n 个要素的矩阵，（m 行,n 列），写一个函数按照螺旋顺序，返回该矩阵中的所有要素。

格式：

输入依次输入两个整数 m 和 n，和一个 m x n 的整数数组，最后输出按照螺旋顺序返回的矩阵数组的元素。

样例输入

m = 3

n = 3

[

 [ 1，2，3]，

 [ 4，5，6]，

 [ 7，8，9]

]

样例输出

[ 1，2，3，6，9，8，7，4，5]

 

 

 

 

 

·给出 2*n + 1 个的数字，除其中一个数字之外其他每个数字均出现两次，写一个函数找到这个数字。

挑战：

一次遍历，常数级的额外空间复杂度

格式：

输入行输入一个数组，最后输出出现一次的数字。

样例输入

[ 1，2，2，1，3，4，3]

样例输出

4

 

 

 

 

 

 

 

·有一些原木，现在想把这些木头切割成一些长度相同的小段木头，需要得到的小段的数目至少为 k。当然，我们希望得到的小段越长越好，编写一个函数计算能够得到的小段木头的最大长度。

注意事项：

木头长度的单位是厘米。原木的长度都是正整数，我们要求切割得到的小段木头的长度也要求是整数。无法切出要求至少 k 段的,则返回0 即可。

格式：

输入第一行输入一个木头长度的数组，接着输入一个整数 k ，最后输出能够得到的小段木头的最大长度。

样例输入

[ 232，124，456]

k = 7

样例输出

114

 

 

 

 

 

 

 

 

·给定一个表达式字符串数组，写一个函数返回该表达式的逆波兰表达式（即去掉括号）。

格式：

第一行输入一个由数字和算符组成的表达式 T，最后输出该表达式的逆波兰表达式。

样例输入

T = [ 3 - 4 + 5 ]

样例输出

[ 3 4 - 5 + ]

 

 

 

 

 

 

·写一个函数分割一个整数数组，使得奇数在前偶数在后。

挑战： 

在原数组中完成，不使用额外空间。

格式：

输入行输入一个整数数组，最后输出分割后的数组。

样例输入

[ 1， 2，3，4 ]

样例输出

[ 1，3，2，4 ]

 

 

 

 

 

 

 

·给出一个有 n 个整数的数组 S，在S 中找到三个整数 a, b, c，使得 a + b + c = 0。写一个函数找到所有满足要求的三元组。

注意事项：

在三元组(a, b, c)，要求a <= b <= c。结果不能包含重复的三元组。

格式：

输入行输入一个有 n 个整数的数组 S，最后输出所有满足要求的三元组。

样例输入

S = [ -1，0，1，2，-1，-4 ]

样例输出

( -1, 0, 1 )

( -1, -1, 2 )

 

 

 

 

 

 

 

 

 

·给出一个字符串 A，表示一个 n 位正整数, 删除其中 k 位数字, 使得剩余的数字仍然按照原来的顺序排列产生一个新的正整数。写一个函数找到删除 k 个数字之后的最小正整数。其中 N <= 240，k <= N。

格式：

输入行依次输入一个字符串代表的正整数 A 和一个整数 k，最后输出删除 k 个数字之后的最小正整数。

样例输入

A = 178542

k = 4

样例输出

12

 

 

 

 

 

 

 

·给出一个候选数字的集合 C 和目标数字 T，写一个函数找到 C 中所有的组合，使找出的数字和为 T。C 中的数字可以无限制重复被选取。

注意事项：

1、所有的数字（包括目标数字）均为正整数。

2、元素组合（a1, a2, … , ak）必须是非降序（ie, a1 ≤  a2  ≤ …≤  ak）。

3、解集不能包含重复的组合。 

格式：

输入行每一行输入数组 C 和一个目标数字 T，最后输出所有满足条件的组合。

样例输入

C = [ 2，3，6，7 ]

T = 7

样例输出

[ [ 7 ]，[ 2，2，3 ] ]

 

 

 

 

 

 

 

 

·给定一个包含 n 个数的整数数组 S，写一个函数在 S 中找到所有使得和为给定整数 target 的四元组 ( a，b，c，d )。

注意事项：

1、四元组 ( a，b，c，d ) 中，需要满足 a <= b <= c <= d

2、答案中不可以包含重复的四元组。

格式：

输入行输入一个有 n 个整数的数组 S 和一个整数 target，最后输出所有满足要求的四元组。

样例输入

S = [ 1，0，-1，0，-2，2 ] 

target = 0

样例输出

( -1，0，0，1 )

( -2，-1，1，2 )

( -2，0，0，2 )

 

 

 

 

 

 

 

 

 

 

 

·给出一个非负整数数组，你最初定位在数组的第一个位置。数组中的每个元素代表你在那个位置可以跳跃的最大长度。写一个函数判断你是否能到达数组的最后一个位置。

注意事项：

这个问题有两个方法，一个是贪心和 动态规划。贪心方法时间复杂度为O（N）。动态规划方法的时间复杂度为为O（n^2）。

我们手动设置小型数据集，使大家可以通过测试的两种方式。这仅仅是为了让大家学会如何使用动态规划的方式解决此问题。如果您用动态规划的方式完成它，你可以尝试贪心法，以使其再次通过一次。

格式：

输入行输入一个整数数组 A，最后输出是否可以到达数组的最后一个位置么，如果可以输出 true，如果不可以输出 false。

样例输入

A = [ 2，3，1，1，4]

样例输出

true

 

 

 

 

 

 

 

 

·写一个函数计算数字 k 在 0 到n 中的出现的次数，k 可能是 0 ~ 9 的一个值。

格式：

输入依次输入一个数字 n，和一个数字 k，最后计算出数字 k 在 0 到 n 中出现的次数。

样例输入

n=12

k=1

样例输出

5

 

 

 

 

 

 

 

 

·给一个正整数 n，写一个函数找到若干个完全平方数（比如 1，4，9，...）使得他们的和等于 n。要求为你需要让平方数的个数最少，输出需要的最少的平方数的个数。

格式：

输入每一行输入一个 整数 n，输出每一行输出需要最少的平方数的个数。

样例输入

n = 12

n = 13

样例输出

3  

//12 = 4 + 4 + 4

2 

//13 = 4 + 9

 

 

 

 

 

 

 

 

·设计一个算法，计算出任意一个整数 n 的阶乘中尾部零的个数

挑战 :

O(logN)的时间复杂度

格式：

输入行第一行输入一个整数 n，最后输出阶乘尾部零的个数。

样例输入

11

样例输出

2

 

 

 

 

 

 

 

·一个数是稀疏数如果这个数的二进制表示中没有相邻的 1，给出一个 n ，写一个函数找出大于或等于 n 的最小的稀疏数。

例如：5（二进制表示为 101）是稀疏数，但是 6 (二进制表示为 110 ）不是稀疏数

格式：

输入第一行依次输入一个整数 n ，最后依次输出大于或等于 n 的最小的稀疏数。

样例输入

n = 6

n = 4

n = 38

样例输出

8

4

40

 

 

 

 

 

 

·给出一个无重叠的按照区间起始端点排序的区间列表。在列表中插入一个新的区间，你要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。写一个函数实现这个功能。

格式：

输入行第一行输入一个待插入的区间，第二行输入原始区间列表，最后输出插入后形成的新的区间。

样例输入

[ 2，5 ] 

[ [ 1，2 ]，[5，9 ] ]

样例输出

[ [ 1，9 ] ]

 

 

 

 

 

 

 

 

 

 

·你给出一个整数数组（size 为 n），其具有以下特点：

1、相邻位置的数字是不同的

2、A[0] < A[1] 并且 A[n - 2] > A[n - 1]

假定P是峰值的位置则满足 A[P] > A[P-1] 且 A[P] > A[P+1]，写一个函数返回数组中所有峰值的位置。

格式：

输入行输入一个整数数组，输出行输出所有数组中的峰值的位置。

样例输入

[ 1，2，1，3，4，5，7，6 ]

样例输出

1，6

 

 

 

 

 

 

 

 

·给定一个包含红，白，蓝且长度为 n 的数组，写一个函数实现将数组元素进行分类使相同颜色的元素相邻，并按照红、白、蓝的顺序进行排序。我们可以使用整数 0，1 和2 分别代表红，白，蓝。

注意事项：

1、不能使用代码库中的排序函数来解决这个问题。

2、排序需要在原数组中进行。

格式：

第一行输入一个由 0，1，2组成的数组，最后输出分类排序后的数组。

样例输入

[ 1，0，1，2 ]

样例输出

[ 0，1，1，2 ]

 

 

 

 

 

 

 

 

 

 

·给定一个字符串，写一个函数验证其是否为数字。

格式：

输入行每一行输入一个字符串，最后输出其是否为数字，如果是则输出 true，不是则输出 false。

样例输入

"0"

" 0.1 " 

"abc" 

"1 a" 

"2e10"

样例输出

true

true

false

false

true

 

 

 

 

 

 

 

 

 

 

·写一个方法, 给一个由 N 个字符构成的字符串 A和一个由 M 个字符构成的字符串 B, 返回A 必须重复的次数，使得 B 是重复字符串的子串。如果 B 不可能为重复字符串的子串, 则返回 -1.

注意事项： 0 <= N <= 1000，1 <= M <= 1000

格式：

输入第一行输入一个 字符串 A，第二行输入一个字符串 B ，最后输出一个整数使得A 重复整数次后，B 是 A 重复后的字符串的子串。

样例输入

A = abcd 

B = cdabcdab

样例输出

3

 

 

 

 

 

 

 

 

·实现atoi这个函数，将一个字符串转换为整数。如果没有合法的整数，返回0。若整数超出了32位整数的范围，如果是正整数则返回 INT_MAX（2147483647），或者如果是负整数则返回 INT_MIN（-2147483648）。

格式：

输入行每一行输入一个字符串，最后每一行输出经过转换后得到的整数。

样例输入

"10" 

"-1" 

"123123123123123" 

"1.0" 

样例输出

10

-1

2147483647

1

 

 

 

 

 

 

 

 

·给定一个含不同整数的集合，写一个函数返回其所有的子集。其中子集中的元素排列必须是非降序的，解集必须不包含重复的子集。

格式：

输入第一行输入一个整数数组的集合，最后输出该集合的所有子集的集合。

样例输入

A = [ 1，2，3]

样例输出

[

  [ 3 ]，

  [ 1 ]，

  [ 2 ]，

  [ 1，2，3]，

  [ 1，3 ]，

  [ 2，3 ]，

  [ 1，2 ]，

  [ ]

]

 

 

 

 

 

 

 

 

 

 

·给出两个整数 n 和 k，写一个函数返回从 1......n 中选出的 k 个数的组合。

格式：

输入行依次输入一个整数 n 和一个整数 k，最后输出所有 k 个数的组合。

样例输入

n = 4 

k = 2

样例输出

[ [ 2，4 ]，[3，4 ]，[ 2，3]，[ 1，2 ]，[1，3 ]，[ 1，4]]

 

 

 

 

 

 

 

·给定一个未经排序的数组，写一个函数找出其排序表中连续两个要素的最大间距。如果数组中的要素少于 2 个，请返回 0。

注意事项：

1、可以假定数组中的所有要素都是非负整数，且最大不超过 32 位整数。

2、用排序的方法解决这个问题是比较简单的方法，但是排序的时间复杂度是O(nlogn), 能否使用线性的时间和空间复杂度的方法解决这个问题。

格式：

输入行输入一个未经排序的数组num，最后输出排序表中两个要素的最大间距。

样例输入

num =  [ 1，9，2，5 ]

样例输出

4

 

 

 

 

 

 

 

·给你一个二维矩阵，权值为 False 和 True，False为0，true 为1写一个函数找到一个最大的矩形，使得里面的值全部为True，并输出它的面积。

格式：

第一行输入一个二维 01 数组，最后输出子矩阵中值全为 True 的面积最大的矩形，最后输出矩形的面积。

样例输入

[

  [ 1, 1, 0, 0, 1 ]，

  [ 0, 1, 0, 0, 1 ]，

  [ 0, 0, 1, 1, 1 ]，

  [ 0, 0, 1, 1, 1 ]，

  [ 0, 0, 0, 0, 1 ]

]

样例输出

6

 

 

 

 

 

 

·给一个二维 01 矩阵，写一个函数实现在二维矩阵的子矩阵中，找到数字全为1的最大正方形，并输出该最大正方形中数字的个数。

格式：

第一行输入一个二维 01 数组，最后输出子矩阵中最大正方形中数字的个数。

样例输入

1 0 1 0 0

1 0 1 1 1

1 1 1 1 1

1 0 0 1 0

样例输出

4

 

 

 

 

 

·给一个包含 n 个整数的数组 num，写一个函数找到和与给定整数 target 最接近的三元组，返回这三个数的和。

注意事项：

只需要返回三元组之和，无需返回三元组本身。

格式：

输入行依次输入一个整数数组 num 和一个给定的整数 target，最后输出和与 target 最接近的三元组的和。

样例输入

num = [ -1，2，1，-4 ]

target = 1

样例输出

2   // -1 + 2 + 1 =2 

 

 

 

 

 

 

 

·若给定两个整数数组（第一个是数组 A，第二个是数组 B），在数组 A 中取 A[ i ]，数组 B 中取 B[ j ]，A[i ] 和 B[ j ] 两者的差越小越好( | A[ i ] - B[ j ] | )，写一个函数返回最小差。

挑战 ：

时间复杂度 O(n log n)

格式：

输入行输入两个整数数组 A 和 B，最后输出返回的最小差。

样例输入

A = [ 3，4，6，7 ]

B = [ 2，3，8，9 ]

样例输出

0

 

 

 

 

 

 

 

 

·给一个整数数组，调整每个数的大小，使得相邻的两个数的差不大于一个给定的整数target，调整每个数的代价为调整前后的差的绝对值，写一个函数求调整代价之和最小是多少。

注意事项：

你可以假设数组中每个整数都是正整数，且小于等于100。

格式：

输入依次输入一个整数数组 num 和一个数字target ，最后输出最小调整代价之和。

样例输入

num = [ 1，4，2，3 ]

target = 1

样例输出

2  // [ 2，3，2，3 ]

 

 

 

 

 

·给出两个字符串，写一个函数找到最长公共子串，并返回其长度。

注意事项：

子串的字符应该连续的出现在原字符串中，这与子序列有所不同。

格式：

输入行输入两个字符串 A 和 B，最后输出最长公共子串的长度。

样例输入

A = “ABCD”

B = “CBCE”

样例输出

2

 

 

Good luck!

Write by Jimmy.li