Skip to content

Commit 8304b81

Browse files
clingoramclingoram
authored
Merge pull request #156 from clingoram/mavis
解題3題
2 parents 2222940 + 27f430e commit 8304b81

4 files changed

Lines changed: 148 additions & 129 deletions

File tree

‎javascript/LeetCode/Array/3678.js‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* 3678. Smallest Absent Positive Greater Than Average
3+
*
4+
* 從nums中找最小缺少的數字，條件：大於nums中所有元素的平均值
5+
* @param {number[]} nums
6+
* @return {number}
7+
*/
8+
var smallestAbsent = function(nums) {
9+
let avg = nums.reduce((a,b) => (a + b) / nums.length);
10+
let ans = 1;
11+
while(true){
12+
if(ans > avg && !nums.includes(ans)){
13+
return ans;
14+
}
15+
ans++;
16+
}
17+
};
18+
let nums = [3,5];
19+
/*
20+
Output: 6
21+
Explanation:
22+
The average of nums is (3 + 5) / 2 = 8 / 2 = 4.
23+
The smallest absent positive integer greater than 4 is 6.
24+
*/
25+
console.log(smallestAbsent(nums));

‎javascript/LeetCode/String/657.js‎

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
/**
2+
* 657. Robot Return to Origin
3+
*
4+
* @param {string} moves
5+
* @return {boolean}
6+
*/
7+
var judgeCircle = function(moves) {
8+
/**
9+
* moves只會有'R' (right), 'L' (left), 'U' (up)和'D' (down)這幾個英文字母
10+
* 回傳布林看moves後是否會回到原點(0, 0)
11+
*
12+
* x(0),y(0)
13+
* u = d
14+
* r = l
15+
*
16+
* 計算每個字母出現次數，r的出現次數 = l的出現次數; u 的出現次數 = d的出現次數
17+
*/
18+
// solution 1.
19+
// TC:O(N)
20+
// let direactionsCount = new Map();
21+
// for(let i = 0;i < moves.length;++i) {
22+
// direactionsCount.has(moves[i]) ? direactionsCount.set(moves[i],direactionsCount.get(moves[i])+1) : direactionsCount.set(moves[i],1);
23+
// }
24+
// // 取得Map.get(key)對應value
25+
// if(direactionsCount.get("U") === direactionsCount.get("D") && direactionsCount.get("R") === direactionsCount.get("L")){
26+
// return true;
27+
// }
28+
// return false;
29+
30+
// another solution
31+
// TC:O(N)
32+
let direactionsObj = {};
33+
for(let i = 0;i < moves.length;++i) {
34+
if(Object.hasOwn(direactionsObj, moves[i])){
35+
direactionsObj[moves[i]] +=1;
36+
}else{
37+
direactionsObj[moves[i]] = 1;
38+
}
39+
}
40+
// console.log(direactionsObj.L)
41+
return direactionsObj.L === direactionsObj.R && direactionsObj.U === direactionsObj.D;
42+
43+
// solution 2.
44+
// TC: O(N)
45+
// 計算x和y各自出現次數
46+
// x = 水平(左l右r); y = 垂直(上u下d)
47+
// 水平(x):
48+
// L:x--; R:x++;
49+
// 垂直(y):
50+
// U:y++ ; D: y--
51+
// let x = 0,y = 0;
52+
// for(let i = 0;i < moves.length;++i) {
53+
// if(moves[i] === 'R'){
54+
// x++;
55+
// }else if(moves[i] === 'U'){
56+
// y++;
57+
// }else if(moves[i] === 'L'){
58+
// x--
59+
// }else if(moves[i] === 'D'){
60+
// y--;
61+
// }
62+
// }
63+
// return x === 0 && y === 0;
64+
65+
};
66+
// let moves = "UD";
67+
/*
68+
Output: true
69+
Explanation: The robot moves up once, and then down once. All moves have the same magnitude, so it ended up at the origin where it started. Therefore, we return true.
70+
*/
71+
let moves = "LL";
72+
/*
73+
Output: false
74+
Explanation: The robot moves left twice. It ends up two "moves" to the left of the origin. We return false because it is not at the origin at the end of its moves.
75+
*/
76+
console.log(judgeCircle(moves));

‎javascript/LeetCode/math/3663.js‎

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
/**
2+
* 3663. Find The Least Frequent Digit
3+
*
4+
* 參數為一整數n，找出在其十進位表示中出現頻率最低的數字。如果多個數字的出現頻率相同，則選擇最小的元素。
5+
* 數字x的出現頻率是指它在n的十進位表示法中的出現次數
6+
*
7+
* @param {number} n
8+
* @return {number}
9+
*/
10+
var getLeastFrequentDigit = function(n) {
11+
/**
12+
* 依據每個數字出現的次數找出出現次數最少的元素，若有好幾個數字出現次數相同，回傳最小的那個元素。
13+
*
14+
* solution 1. Hash table
15+
*/
16+
17+
// solution 1.
18+
// Hash table
19+
let nSplitToStr = n.toString().split("");
20+
let map = new Map();
21+
let minFreq = Infinity,result = 10;
22+
for(let i = 0;i < nSplitToStr.length;++i) {
23+
map.has(nSplitToStr[i]) ? map.set(nSplitToStr[i],map.get(nSplitToStr[i]) + 1) : map.set(nSplitToStr[i],1);
24+
}
25+
// 不斷比較minFreq和value哪個最小，因此minFreq值會一直更新
26+
for(const [key,value] of map){
27+
minFreq = Math.min(minFreq,value);
28+
}
29+
for(const [key,value] of map){
30+
// 最小的value = minFreq
31+
if(value === minFreq){
32+
// 比較result和key哪個最小，key = 元素
33+
result = Math.min(result,key);
34+
}
35+
}
36+
return reuslt;
37+
38+
};
39+
let n = 723344511;
40+
/*
41+
Output: 2
42+
Explanation:
43+
The least frequent digits in n are 7, 2, and 5; each appears only once.
44+
*/
45+
console.log(getLeastFrequentDigit(n));

‎javascript/index.js‎

Lines changed: 2 additions & 129 deletions
Original file line numberDiff line numberDiff line change
@@ -1317,133 +1317,8 @@ var findAndReplacePattern = function(words, pattern) {
13171317
// ["mee","aqq"]
13181318
// console.log(findAndReplacePattern(word,pattern));
13191319

1320-
/**
1321-
* 657. Robot Return to Origin
1322-
*
1323-
* @param {string} moves
1324-
* @return {boolean}
1325-
*/
1326-
var judgeCircle = function(moves) {
1327-
/**
1328-
* moves只會有'R' (right), 'L' (left), 'U' (up)和'D' (down)這幾個英文字母
1329-
* 回傳布林看moves後是否會回到原點(0, 0)
1330-
*
1331-
* x(0),y(0)
1332-
* u = d
1333-
* r = l
1334-
*
1335-
* 計算每個字母出現次數，r的出現次數 = l的出現次數; u 的出現次數 = d的出現次數
1336-
*/
1337-
// solution 1.
1338-
// TC:O(N)
1339-
// let direactionsCount = new Map();
1340-
// for(let i = 0;i < moves.length;++i) {
1341-
// direactionsCount.has(moves[i]) ? direactionsCount.set(moves[i],direactionsCount.get(moves[i])+1) : direactionsCount.set(moves[i],1);
1342-
// }
1343-
// // 取得Map.get(key)對應value
1344-
// if(direactionsCount.get("U") === direactionsCount.get("D") && direactionsCount.get("R") === direactionsCount.get("L")){
1345-
// return true;
1346-
// }
1347-
// return false;
1348-
1349-
// this solution?
1350-
let direactionsObj = {};
1351-
for(let i = 0;i < moves.length;++i) {
1352-
if(Object.hasOwn(direactionsObj, moves[i])){
1353-
direactionsObj[moves[i]] +=1;
1354-
}else{
1355-
direactionsObj[moves[i]] = 1;
1356-
}
1357-
}
1358-
console.log(direactionsObj)
13591320

1360-
// solution 2.
1361-
// TC: O(N)
1362-
// 計算x和y各自出現次數
1363-
// x = 水平(左l右r); y = 垂直(上u下d)
1364-
// 水平(x):
1365-
// L:x--; R:x++;
1366-
// 垂直(y):
1367-
// U:y++ ; D: y--
1368-
// let x = 0,y = 0;
1369-
// for(let i = 0;i < moves.length;++i) {
1370-
// if(moves[i] === 'R'){
1371-
// x++;
1372-
// }else if(moves[i] === 'U'){
1373-
// y++;
1374-
// }else if(moves[i] === 'L'){
1375-
// x--
1376-
// }else if(moves[i] === 'D'){
1377-
// y--;
1378-
// }
1379-
// }
1380-
// return x === 0 && y === 0;
13811321

1382-
};
1383-
let moves = "UD";
1384-
/*
1385-
Output: true
1386-
Explanation: The robot moves up once, and then down once. All moves have the same magnitude, so it ended up at the origin where it started. Therefore, we return true.
1387-
*/
1388-
// let moves = "LL";
1389-
/*
1390-
Output: false
1391-
Explanation: The robot moves left twice. It ends up two "moves" to the left of the origin. We return false because it is not at the origin at the end of its moves.
1392-
*/
1393-
// console.log(judgeCircle(moves));
1394-
1395-
/**
1396-
* 3663. Find The Least Frequent Digit
1397-
*
1398-
* 參數為一整數n，找出在其十進位表示中出現頻率最低的數字。如果多個數字的出現頻率相同，則選擇最小的元素。
1399-
* 數字x的出現頻率是指它在n的十進位表示法中的出現次數
1400-
*
1401-
* @param {number} n
1402-
* @return {number}
1403-
*/
1404-
var getLeastFrequentDigit = function(n) {
1405-
/**
1406-
* 依據每個數字出現的次數找出出現次數最少的元素，若有好幾個數字出現次數相同，回傳最小的那個元素。
1407-
*
1408-
* solution 1. Hash table
1409-
* solution 2. Array
1410-
*/
1411-
1412-
// solution 1.
1413-
// Hash table
1414-
// let nSplitToStr = n.toString().split("");
1415-
// let map = new Map();
1416-
// let minFreq = Infinity,result = 10;
1417-
// for(let i = 0;i < nSplitToStr.length;++i) {
1418-
// map.has(nSplitToStr[i]) ? map.set(nSplitToStr[i],map.get(nSplitToStr[i]) + 1) : map.set(nSplitToStr[i],1);
1419-
// }
1420-
// 不斷比較minFreq和value哪個最小，因此minFreq值會一直更新
1421-
// for(const [key,value] of map){
1422-
// minFreq = Math.min(minFreq,value);
1423-
// }
1424-
// for(const [key,value] of map){
1425-
// // 最小的value = minFreq
1426-
// if(value === minFreq){
1427-
// // 比較result和key哪個最小，key = 元素
1428-
// result = Math.min(result,key);
1429-
// }
1430-
// }
1431-
// return reuslt;
1432-
1433-
// solution 2.
1434-
// Array.
1435-
let hash = new Array(10).fill(0);
1436-
let ans = 0,minFreq = 0;
1437-
console.log(hash)
1438-
1439-
};
1440-
let n = 723344511;
1441-
/*
1442-
Output: 2
1443-
Explanation:
1444-
The least frequent digits in n are 7, 2, and 5; each appears only once.
1445-
*/
1446-
// console.log(getLeastFrequentDigit(n));
14471322

14481323
/**
14491324
* 3488. Closest Equal Element Queries
@@ -1500,14 +1375,12 @@ var solveQueries = function(nums, queries) {
15001375
}
15011376

15021377
};
1503-
let nums = [1,3,1,4,1,3,2], queries = [0,3,5];
1378+
// let nums = [1,3,1,4,1,3,2], queries = [0,3,5];
15041379
/*
15051380
Output: [2,-1,3]
15061381
Explanation:
15071382
Query 0: The element at queries[0] = 0 is nums[0] = 1. The nearest index with the same value is 2, and the distance between them is 2.
15081383
Query 1: The element at queries[1] = 3 is nums[3] = 4. No other index contains 4, so the result is -1.
15091384
Query 2: The element at queries[2] = 5 is nums[5] = 3. The nearest index with the same value is 1, and the distance between them is 3 (following the circular path: 5 -> 6 -> 0 -> 1).
15101385
*/
1511-
// console.log(solveQueries(nums,queries));
1512-
1513-
1386+
// console.log(solveQueries(nums,queries));

0 commit comments

Comments
 (0)