-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathtopic.html
515 lines (394 loc) · 14.8 KB
/
topic.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>topic</title>
</head>
<body>
<script>
/*
506 -> 相对名次
前三名运动员的成绩为前三高的，因此将会分别被授予 “金牌”，“银牌”和“铜牌” ("Gold Medal", "Silver Medal" and "Bronze Medal").
余下的两名运动员，我们只需要通过他们的成绩计算将其相对名次即可。
思路:
使用while循环,变量n为数组nums里数字类型值的最大值.
在数组nums里删除当前的n,判断是否是前三名,是就取ranking数组的值,否则取它的名次.
*/
var findRelativeRanks = function(nums) {
const ranking = ['Gold Medal', 'Silver Medal', 'Bronze Medal']
let ii = 0
while (ii < nums.length) {
const n = Math.max(...nums.filter(i => typeof i === 'number'))
nums.splice(nums.indexOf(n), 1, ii < 3 ? ranking[ii] : ii + 1 + '')
ii += 1
}
return nums
}
console.log(findRelativeRanks([5,4,3,2,1]))
console.log(findRelativeRanks([10,3,8,9,4]))
/*
520 -> 检测大写字母
给定一个单词，你需要判断单词的大写使用是否正确。
我们定义，在以下情况时，单词的大写用法是正确的：
1. 全部字母都是大写，比如"USA"。
2. 单词中所有字母都不是大写，比如"leetcode"。
3. 如果单词不只含有一个字母，只有首字母大写， 比如 "Google"。
否则，我们定义这个单词没有正确使用大写字母。
思路:
判断全是大写或者全是小写的话,返回true.
否则的话首字母大写,其余小写.
*/
var detectCapitalUse = function(word) {
if (word === word.toUpperCase()) return true
if (word === word.toLowerCase()) return true
const newWord = word.slice(0,1).toUpperCase() + word.slice(1).toLowerCase()
return newWord === word
}
console.log(detectCapitalUse('USA'))
console.log(detectCapitalUse('FlaG'))
// 14 -> 最长公共前缀
var longestCommonPrefix = function(strs) {
if (strs.length === 1) return strs.toString()
if ([...new Set(strs)].length === 1) return strs[0]
let n = 0
let yes = true
while (yes) {
n += 1
const len = [...new Set(strs.map(i => i.slice(0, n)))].length
yes = len === 1
}
return n - 1 ? strs[0].slice(0, n - 1) : ''
}
console.log(longestCommonPrefix(["flower","flow","flight"]))
console.log(longestCommonPrefix(["dog","racecar","car"]))
console.log(longestCommonPrefix(["c", "c"]))
console.log(longestCommonPrefix(["a", "a", "b"]))
console.log(longestCommonPrefix(["ab","abcc"]))
console.log(longestCommonPrefix(["abca","abc"]))
// 633 -> 平方数之和
var judgeSquareSum = function(c) {
let b = Math.ceil(Math.sqrt(c))
let a = 0
while (b >= a) {
const num = a ** 2 + b ** 2
if (num === c) return true
if (num > c) b -= 1
if (num < c) a += 1
}
return false
}
console.log(judgeSquareSum(4))
// 350 -> 数组的交集 ||
var intersect = function(nums1, nums2) {
const list = []
const o = {}
// 利用hash映射
for (let i = 0;i < nums1.length;i++) {
if (o[nums1[i]]) {
o[nums1[i]] += 1
} else {
o[nums1[i]] = 1
}
}
for (let i = 0;i < nums2.length;i++) {
if (o[nums2[i]]) {
o[nums2[i]] -= 1
list.push(nums2[i])
}
}
return list
}
console.log(intersect([1,2,2,1], [2,2]))
console.log(intersect([],[1,1]))
// 349 -> 两个数组的交集
var intersection = function(nums1, nums2) {
const list = []
nums1.forEach(i => {
if (nums2.includes(i)) {
!list.includes(i) && list.push(i)
}
})
return list
}
console.log(intersection([1,2,2,1], [2,2]))
console.log(intersection([4,9,5], [9,4,9,8,4]))
// 28 -> 实现strStr()
var strStr = function(haystack, needle) {
if (!needle) return 0
if (!haystack.includes(needle)) return -1
return haystack.indexOf(needle)
}
console.log(strStr('hello', 'll'))
console.log(strStr('aaaaa', 'bba'))
// 118 -> 杨辉三角 (自我感觉这道题还是有点难的 0.0 没想到竟然做出来了 佩服自己🤣)
// [
// [1],
// [1,1],
// [1,2,1],
// [1,3,3,1],
// [1,4,6,4,1]
// ]
var generate = function(numRows) {
const list = new Array(numRows).fill('').map((i, idx) => new Array(idx + 1).fill(1))
list.forEach((i,idx) => {
if (idx > 1) {
const arr = []
for (let j = 0;j < list[idx - 1].length;j++) {
j && arr.push(list[idx - 1][j - 1] + list[idx - 1][j])
}
list[idx] = [1, ...arr, 1]
}
})
return list
}
console.log(generate(5))
// 977 -> 有序数组的平方 (很简单的一道题)
var sortedSquares = function(A) {
return A.map(i => i ** 2).sort((a,b) => a - b)
}
// 1047 -> 删除字符串中的所有相邻重复项
var removeDuplicates = function(S) {
const toHeavy = str => {
return /(\w)\1/g.test(str) ? toHeavy(str.replace(/(\w)\1/g, '')) : str
}
return toHeavy(S)
}
console.log(removeDuplicates('abbaca')) // 'ca'
// 884 -> 两句话中的不常见单词
var uncommonFromSentences = function(A, B) {
return A.split(' ').concat(B.split(' ')).reduce((acc, next, index, array) => {
if (array.indexOf(next) === array.lastIndexOf(next)) {
acc.push(next)
}
return acc
}, [])
}
console.log(uncommonFromSentences('this apple is sweet', 'this apple is sour'))
console.log(uncommonFromSentences('apple apple', 'banana'))
/*
896 -> 单调数列
如果数组是单调递增或单调递减的，那么它是单调的。
如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。
当给定的数组 A 是单调数组时返回 true，否则返回 false。
思路：
1. 简单的方法将A按从小到大和从大到小的方式排列起来转为字符串存到list里
如果list里有B为true,否则为false
(声明B的原因是因为sort排序会改变原数组)
2. 先判断数组length为1的情况,接着用orderBy判断顺序是从小到大还是从大到小
然后for循环,根据orderBy判断是否满足A[i] > A[i - 1]或者A[i] < A[i - 1],
如果满足,即为false,否则为true
*/
var isMonotonic = function(A) {
const B = [...A]
const list = [A.sort((a, b) => a - b).toString(), A.sort((a, b) => b - a).toString()]
return list.includes(B.toString())
}
var isMonotonic = function(A) {
if (A.length === 1) return true
const orderBy = A[0] > A[A.length - 1]
for (let i = 1; i < A.length; i++) {
if (orderBy ? A[i] > A[i - 1] : A[i] < A[i - 1]) {
return false
}
}
return true
}
console.log(isMonotonic([1,2,2,3]))
console.log(isMonotonic([6,5,4,4]))
console.log(isMonotonic([1,3,2]))
console.log(isMonotonic([1,2,2,1]))
/*
929 -> 独特的电子邮件地址
每封电子邮件都由一个本地名称和一个域名组成，以 @ 符号分隔。
例如，在 [email protected]中， alice 是本地名称，而 leetcode.com 是域名。
除了小写字母，这些电子邮件还可能包含 '.' 或 '+'。
如果在电子邮件地址的本地名称部分中的某些字符之间添加句点（'.'），则发往那里的邮件将会转发到本地名称中没有点的同一地址。例如，"[email protected]” 和 “[email protected]” 会转发到同一电子邮件地址。 （请注意，此规则不适用于域名。）
如果在本地名称中添加加号（'+'），则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件，例如 [email protected] 将转发到 [email protected]。 （同样，此规则不适用于域名。）
可以同时使用这两个规则。
给定电子邮件列表 emails，我们会向列表中的每个地址发送一封电子邮件。实际收到邮件的不同地址有多少？
思路：
例: '[email protected]'
/\+([a-z]|\.)*\/g这条正则,用于匹配+号之后的字母或.,然后进行替换
然后split用@分隔,替换第0个的所有.为'',然后再拼接起来,进行去重.
*/
var numUniqueEmails = function(emails) {
return [...new Set(emails.map(i => {
const str = i.replace(/\+([a-z]|\.)*/g, '').split('@')
return `${str[0].replace(/\./g, '')}@${str[1]}`
}))].length
}
console.log(numUniqueEmails([
]))
/*
258 -> 各位相加
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数
思路：
while循环,只要num大于10,就把num转成字符串然后转为数组进行累加
*/
var addDigits = function(num) {
while (num >= 10) {
num = [...(num.toString())].reduce((a,b) => Number(a) + Number(b),0)
}
return num
}
/*
268 -> 缺失数字
给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。
思路：
通过nums的length+1生成新的数组的值的和减去nums数组的值的和就是缺失的数字
*/
var missingNumber = function(nums) {
if (nums.length == 1 && !nums[0]) return 1
return new Array(nums.length + 1).fill(1).reduce((a,b,c) => a + c,0) - nums.reduce((a,b) => a + b,0)
}
/*
905 -> 按奇偶排序数组
给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
你可以返回满足此条件的任何数组作为答案。
思路：
1. 声明两个数组 一个用来放奇数 一个用来放偶数 就ok
2. 拿到数组的长度进行循环 如果是奇数从数组中删除添加到数组后边
*/
var sortArrayByParity = function(A) {
let arr = []
let arr2 = []
for (let i = 0;i < A.length;i++) {
if (A[i] % 2 === 1) {
arr.push(A[i])
} else {
arr2.push(A[i])
}
}
return [...arr2, ...arr]
let len = A.length
for (let i = 0;i < len;i++) {
if (A[i] % 2 === 1) {
A.push(A.splice(i, 1)[0])
i--
len--
}
}
return A
}
console.log(sortArrayByParity([3,1,2,4]))
/*
263 -> 丑数
编写一个程序判断给定的数是否为丑数。
丑数就是只包含质因数 2, 3, 5 的正整数。
思路：
很简单的一道题 看一下代码应该就可以懂
*/
var isUgly = function(num) {
if (num <= 0) {
return false
}
while (num % 2 == 0) {
num /= 2
}
while (num % 3 == 0) {
num /= 3
}
while (num % 5 == 0) {
num /= 5
}
return num == 1
}
/*
283 -> 移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
思路：
从大到小循环 为0就删除并添加到nums后边
*/
var moveZeroes = function(nums) {
for (let i = nums.length;i >= 0;i--) {
if (nums[i] === 0) {
nums.push(nums.splice(i,1)[0])
}
}
}
/*
989 -> 数组形式的整数加法
对于非负整数 X 而言，X 的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果 X = 1231，那么其数组形式为 [1,2,3,1]。
给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。
思路：
感觉好像写的有点复杂
1. 首先声明ken等于K转字符串转数组然后map把每一项转为数字
2. 声明B A的长度大于等于ken的长度 ？ B就是反转的A 否则创建一个长度为ken与A的差的数组添加0然后拼接起来再反转
3. 循环B
4. 如果有ken[i]有的话 然后判断是否大于9 大于9前一位加1 个位再赋值 否则直接相加再赋值
5. 没有ken[1]的话 不用相加了 就判断是否大于9 大于9前一位加1 个位再赋值
*/
var addToArrayForm = function(A, K) {
const ken = String(K).split('').reverse().map(Number)
const B = A.length >= ken.length ? A.reverse() : new Array(ken.length - A.length).fill(0).concat(A).reverse()
for (let i = 0;i < B.length;i++) {
if (ken[i] != undefined) {
if (B[i] + ken[i] > 9) {
B[i + 1] = B[i + 1] ? ++B[i + 1] : 1
B[i] = String(B[i] + ken[i])[1] * 1
} else {
B[i] = B[i] + ken[i]
}
} else {
if (B[i] > 9) {
B[i + 1] = B[i + 1] ? ++B[i + 1] : 1
B[i] = String(B[i])[1] * 1
}
}
}
return B.reverse()
}
console.log(addToArrayForm([1], 33))
console.log(addToArrayForm([0], 23))
console.log(addToArrayForm([9,9,9,9,9,9,9,9,9,9], 1))
console.log(addToArrayForm([1,2,6,3,0,7,1,7,1,9,7,5,6,6,4,4,0,0,6,3], 516))
console.log(addToArrayForm([2,7,4], 181))
console.log(addToArrayForm([2,1,5], 806))
/*
567 -> 字符串的排列
给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。
换句话说，第一个字符串的排列之一是第二个字符串的子串。
思路：
0.0 超时了 for循环 按s1的长度 在s2里截取 然后转数组排序对比 一样就true 否则就false 可以解答出来 时间太长了 测试题里有一个超长的字符串- -
*/
var checkInclusion = function(s1, s2) {
const a = s1.split('').sort().join('')
for (let i = 0;i < s2.length;i++) {
const b = s2.slice(i, i + s1.length).split('').sort().join('')
if (a == b) return true
}
return false
}
// console.log(checkInclusion('abc', 'bbbca'))
// console.log(checkInclusion('ab', 'eidbaooo'))
// console.log(checkInclusion('ab', 'eidboaoo'))
console.log(checkInclusion('adc', 'dcda'))
/*
914. 卡牌分组
给定一副牌，每张牌上都写着一个整数。
此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：
* 每组都有 X 张牌。
* 组内所有的牌上都写着相同的整数。
仅当你可选的 X >= 2 时返回 true。
*/
const hasGroupsSizeX = function(deck) {
if (deck.length === 1) return false
const gcd = (a, b) => b ? gcd(b, a % b) : a;
const obj = deck.reduce((acc, item) => {
acc[item] ? acc[item]++ : acc[item] = 1
return acc
}, {})
const sortList = Object.values(obj).sort((a, b) => a - b)
return sortList.reduce((acc, item) => {
return gcd(acc, item)
}) !== 1
}
console.log(hasGroupsSizeX([1,2,3,4,4,3,2,1]))
console.log(hasGroupsSizeX([1,1,2,2,2,2]))
console.log(hasGroupsSizeX([1,1,1,2,2,2,3,3,3]))
</script>
</body>
</html>