682. 棒球比賽
題目鏈接
682. 棒球比賽
題目描述
你現在是一場采用特殊賽制棒球比賽的記錄員，這場比賽由若干回合組成，過去幾回合的得分可能會影響以后幾回合的得分，
比賽開始時，記錄是空白的，你會得到一個記錄操作的字串串列 ops，其中 ops[i] 是你需要記錄的第 i 項操作，ops 遵循下述規則：
- 整數
x- 表示本回合新獲得分數x "+"- 表示本回合新獲得的得分是前兩次得分的總和，題目資料保證記錄此操作時前面總是存在兩個有效的分數，"D"- 表示本回合新獲得的得分是前一次得分的兩倍，題目資料保證記錄此操作時前面總是存在一個有效的分數，"C"- 表示前一次得分無效，將其從記錄中移除，題目資料保證記錄此操作時前面總是存在一個有效的分數，
請你回傳記錄中所有得分的總和，
示例 1：
輸入：ops = ["5","2","C","D","+"]
輸出：30
解釋：
"5" - 記錄加 5 ，記錄現在是 [5]
"2" - 記錄加 2 ，記錄現在是 [5, 2]
"C" - 使前一次得分的記錄無效并將其移除，記錄現在是 [5].
"D" - 記錄加 2 * 5 = 10 ，記錄現在是 [5, 10].
"+" - 記錄加 5 + 10 = 15 ，記錄現在是 [5, 10, 15].
所有得分的總和 5 + 10 + 15 = 30示例 2：
輸入：ops = ["5","-2","4","C","D","9","+","+"]
輸出：27
解釋：
"5" - 記錄加 5 ，記錄現在是 [5]
"-2" - 記錄加 -2 ，記錄現在是 [5, -2]
"4" - 記錄加 4 ，記錄現在是 [5, -2, 4]
"C" - 使前一次得分的記錄無效并將其移除，記錄現在是 [5, -2]
"D" - 記錄加 2 * -2 = -4 ，記錄現在是 [5, -2, -4]
"9" - 記錄加 9 ，記錄現在是 [5, -2, -4, 9]
"+" - 記錄加 -4 + 9 = 5 ，記錄現在是 [5, -2, -4, 9, 5]
"+" - 記錄加 9 + 5 = 14 ，記錄現在是 [5, -2, -4, 9, 5, 14]
所有得分的總和 5 + -2 + -4 + 9 + 5 + 14 = 27示例 3：
輸入：ops = ["1"]
輸出：1
提示：
1 <= ops.length <= 1000ops[i]為"C"、"D"、"+"，或者一個表示整數的字串，整數范圍是[-3 * 104, 3 * 104]- 對于
"+"操作，題目資料保證記錄此操作時前面總是存在兩個有效的分數 - 對于
"C"和"D"操作，題目資料保證記錄此操作時前面總是存在一個有效的分數
解答思路一【Java】
時間2 ms 擊敗 84.55%
記憶體39.7 MB 擊敗 34.74%
典型的模擬題，這道題沒啥特別的，跟著題目給的思路走就可以了
- 首先創建一個堆疊（Stack）用于存盤得分，
- 遍歷操作陣列中的每個操作，
- 對于每個操作，
- 如果是"+"操作，將堆疊頂元素彈出，與新的堆疊頂元素相加后再將原來的堆疊頂元素重新入堆疊，
- 如果是"D"操作，將堆疊頂元素乘以2后入堆疊，
- 如果是"C"操作，將堆疊頂元素彈出，
- 如果是數字操作，將該操作轉換為整數后入堆疊，
- 遍歷完操作陣列后，將堆疊中剩余的元素彈出并累加得分，
- 回傳得分結果，
import java.util.Stack;
class Solution {
public int calPoints(String[] operations) {
Stack<Integer> stack = new Stack<>();
for (String op : operations) {
if (op.equals("+")) {
int top = stack.pop();
int newTop = top + stack.peek();
stack.push(top);
stack.push(newTop);
} else if (op.equals("D")) {
stack.push(stack.peek() * 2);
} else if (op.equals("C")) {
stack.pop();
} else {
stack.push(Integer.parseInt(op));
}
}
int sum = 0;
while (!stack.isEmpty()) {
sum += stack.pop();
}
return sum;
}
}這段代碼涉及的知識點包括：
- 堆疊（Stack）：用于存盤得分的資料結構，
- 字串操作：通過判斷操作字串的內容來執行相應的操作，
- 型別轉換：將字串轉換為整數型別，
- 回圈結構：通過回圈遍歷操作陣列和堆疊的元素，
- 條件判斷：通過條件判斷陳述句來判斷操作的型別，并執行相應的操作，
657. 機器人能否回傳原點
題目鏈接
657. 機器人能否回傳原點
題目描述
在二維平面上，有一個機器人從原點 (0, 0) 開始，給出它的移動順序，判斷這個機器人在完成移動后是否在 (0, 0) 處結束，
移動順序由字串 moves 表示，字符 move[i] 表示其第 i 次移動，機器人的有效動作有 R（右），L（左），U（上）和 D（下），
如果機器人在完成所有動作后回傳原點，則回傳 true，否則，回傳 false，
注意：機器人“面朝”的方向無關緊要， “R” 將始終使機器人向右移動一次，“L” 將始終向左移動等，此外，假設每次移動機器人的移動幅度相同，
示例 1:
輸入: moves = "UD"
輸出: true
解釋：機器人向上移動一次，然后向下移動一次，所有動作都具有相同的幅度，因此它最侄訓到它開始的原點，因此，我們回傳 true，示例 2:
輸入: moves = "LL"
輸出: false
解釋：機器人向左移動兩次，它最終位于原點的左側，距原點有兩次 “移動” 的距離，我們回傳 false，因為它在移動結束時沒有回傳原點，解答思路一【Java】
時間4 ms 擊敗 95.89%
記憶體42.4 MB 擊敗 43.39%
- 首先定義兩個變數x和y，用于記錄橫向和縱向移動的次數，初始值都為0，
- 遍歷移動操作字串中的每個字符，
- 對于每個移動操作字符，
- 如果是'R'，表示向右移動，則將x加1，
- 如果是'L'，表示向左移動，則將x減1，
- 如果是'U'，表示向上移動，則將y加1，
- 如果是'D'，表示向下移動，則將y減1，
- 遍歷完移動操作字串后，判斷x和y是否都為0，
- 如果都為0，表示移動操作會回到原點，回傳true，
- 如果有任何一個不為0，表示移動操作不會回到原點，回傳false，
class Solution {
public boolean judgeCircle(String moves) {
int x = 0; // 橫向移動次數
int y = 0; // 縱向移動次數
for (char move : moves.toCharArray()) {
if (move == 'R') {
x++;
} else if (move == 'L') {
x--;
} else if (move == 'U') {
y++;
} else if (move == 'D') {
y--;
}
}
return x == 0 && y == 0;
}
}這段代碼涉及的知識點包括：
- 字串操作：遍歷移動操作字串中的每個字符，
- 回圈結構：通過回圈遍歷移動操作字串的每個字符，
- 條件判斷：通過條件判斷陳述句判斷移動操作的型別，并執行相應的操作，
- 變數的增減操作：根據移動操作的型別，對變數進行累加或累減操作，
- 回傳結果：根據最后計算出的x和y的值，判斷移動操作是否會回到原點，并回傳相應的結果，
1275. 找出井字棋的獲勝者
題目鏈接
1275. 找出井字棋的獲勝者
題目描述
A 和 B 在一個 3 x 3 的網格上玩井字棋，
井字棋游戲的規則如下：
- 玩家輪流將棋子放在空方格 (" ") 上，
- 第一個玩家 A 總是用 "X" 作為棋子，而第二個玩家 B 總是用 "O" 作為棋子，
- "X" 和 "O" 只能放在空方格中，而不能放在已經被占用的方格上，
- 只要有 3 個相同的（非空）棋子排成一條直線（行、列、對角線）時，游戲結束，
- 如果所有方塊都放滿棋子（不為空），游戲也會結束，
- 游戲結束后，棋子無法再進行任何移動，
給你一個陣列 moves，其中每個元素是大小為 2 的另一個陣列（元素分別對應網格的行和列），它按照 A 和 B 的行動順序（先 A 后 B）記錄了兩人各自的棋子位置，
如果游戲存在獲勝者（A 或 B），就回傳該游戲的獲勝者；如果游戲以平局結束，則回傳 "Draw"；如果仍會有行動（游戲未結束），則回傳 "Pending"，
你可以假設 moves 都 有效（遵循井字棋規則），網格最初是空的，A 將先行動，
示例 1：
輸入：moves = [[0,0],[2,0],[1,1],[2,1],[2,2]]
輸出："A"
解釋："A" 獲勝，他總是先走，
"X " "X " "X " "X " "X "
" " -> " " -> " X " -> " X " -> " X "
" " "O " "O " "OO " "OOX"示例 2：
輸入：moves = [[0,0],[1,1],[0,1],[0,2],[1,0],[2,0]]
輸出："B"
解釋："B" 獲勝，
"X " "X " "XX " "XXO" "XXO" "XXO"
" " -> " O " -> " O " -> " O " -> "XO " -> "XO "
" " " " " " " " " " "O "示例 3：
輸入：moves = [[0,0],[1,1],[2,0],[1,0],[1,2],[2,1],[0,1],[0,2],[2,2]]
輸出："Draw"
輸出：由于沒有辦法再行動，游戲以平局結束，
"XXO"
"OOX"
"XOX"示例 4：
輸入：moves = [[0,0],[1,1]]
輸出："Pending"
解釋：游戲還沒有結束，
"X "
" O "
" "
提示：
1 <= moves.length <= 9moves[i].length == 20 <= moves[i][j] <= 2moves里沒有重復的元素，moves遵循井字棋的規則，
解答思路一【Java】
時間0 ms 擊敗 100%
記憶體39.3 MB 擊敗 12.26%
- 首先創建一個3x3的二維陣列grid，用于表示井字棋的網格，
- 創建一個變數player，用于表示當前玩家的ID，初始值為1，表示玩家A，
- 遍歷moves陣列中的每個落子操作，
- 對于每個落子操作，提取出行號和列號，并將對應位置的二維陣列中的元素更新為當前玩家的ID，然后切換到下一個玩家，
- 遍歷檢查行和列的勝利情況：
- 如果某一行或某一列的格子中的元素都相同且不為0，則表示有玩家獲勝，根據該格子中的元素判斷獲勝的玩家是A還是B，
- 檢查對角線的勝利情況：
- 如果兩條對角線上的格子中的元素都相同且不為0，則表示有玩家獲勝，根據該格子中的元素判斷獲勝的玩家是A還是B，
- 檢查是否還有空方格：
- 如果所有格子都不為0，表示棋盤已經填滿，但沒有玩家獲勝，回傳"Draw"表示平局，
- 如果以上條件都不滿足，則回傳"Pending"表示棋局還未結束，
class Solution {
public String tictactoe(int[][] moves) {
int[][] grid = new int[3][3]; // 二維陣串列示井字棋網格
int player = 1; // 玩家ID，1表示A, -1表示B
for (int[] move : moves) {
int row = move[0]; // 當前落子的行號
int col = move[1]; // 當前落子的列號
grid[row][col] = player; // 更新網格
player = -player; // 切換玩家
}
// 檢查行和列
for (int i = 0; i < 3; i++) {
if (grid[i][0] != 0 && grid[i][0] == grid[i][1] && grid[i][0] == grid[i][2]) {
return grid[i][0] == 1 ? "A" : "B";
}
if (grid[0][i] != 0 && grid[0][i] == grid[1][i] && grid[0][i] == grid[2][i]) {
return grid[0][i] == 1 ? "A" : "B";
}
}
// 檢查對角線
if (grid[0][0] != 0 && grid[0][0] == grid[1][1] && grid[0][0] == grid[2][2]) {
return grid[0][0] == 1 ? "A" : "B";
}
if (grid[0][2] != 0 && grid[0][2] == grid[1][1] && grid[0][2] == grid[2][0]) {
return grid[0][2] == 1 ? "A" : "B";
}
// 檢查是否有空方格
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (grid[i][j] == 0) {
return "Pending";
}
}
}
// 沒有獲勝者且無空方格，平局
return "Draw";
}
}這段代碼涉及的知識點包括：
- 二維陣列：用于表示井字棋的網格，
- 回圈結構：通過回圈遍歷落子操作陣列和網格中的元素，
- 條件判斷：通過條件判斷陳述句判斷勝利的情況和平局的情況，
- 陣列的索引和賦值：通過索引獲取到二維陣列中的元素，并對元素進行賦值，
- 變數的切換和使用：通過player變數切換玩家，并根據當前玩家的ID進行操作，
- 回傳結果：根據檢查的結果，回傳相應的勝負結果或平局結果，
1041. 困于環中的機器人
題目鏈接
1041. 困于環中的機器人
題目描述
在無限的平面上，機器人最初位于 (0, 0) 處，面朝北方，注意:
- 北方向 是y軸的正方向，
- 南方向 是y軸的負方向，
- 東方向 是x軸的正方向，
- 西方向 是x軸的負方向，
機器人可以接受下列三條指令之一：
"G"：直走 1 個單位"L"：左轉 90 度"R"：右轉 90 度
機器人按順序執行指令 instructions，并一直重復它們，
只有在平面中存在環使得機器人永遠無法離開時，回傳 true，否則，回傳 false，
示例 1：
輸入：instructions = "GGLLGG"
輸出：true
解釋：機器人最初在(0,0)處，面向北方，
“G”:移動一步，位置:(0,1)方向:北，
“G”:移動一步，位置:(0,2).方向:北，
“L”:逆時針旋轉90度，位置:(0,2).方向:西，
“L”:逆時針旋轉90度，位置:(0,2)方向:南，
“G”:移動一步，位置:(0,1)方向:南，
“G”:移動一步，位置:(0,0)方向:南，
重復指令，機器人進入回圈:(0,0)——>(0,1)——>(0,2)——>(0,1)——>(0,0)，
在此基礎上，我們回傳true，示例 2：
輸入：instructions = "GG"
輸出：false
解釋：機器人最初在(0,0)處，面向北方，
“G”:移動一步，位置:(0,1)方向:北，
“G”:移動一步，位置:(0,2).方向:北，
重復這些指示，繼續朝北前進，不會進入回圈，
在此基礎上，回傳false，示例 3：
輸入：instructions = "GL"
輸出：true
解釋：機器人最初在(0,0)處，面向北方，
“G”:移動一步，位置:(0,1)方向:北，
“L”:逆時針旋轉90度，位置:(0,1).方向:西，
“G”:移動一步，位置:(- 1,1)方向:西，
“L”:逆時針旋轉90度，位置:(- 1,1)方向:南，
“G”:移動一步，位置:(- 1,0)方向:南，
“L”:逆時針旋轉90度，位置:(- 1,0)方向:東方，
“G”:移動一步，位置:(0,0)方向:東方，
“L”:逆時針旋轉90度，位置:(0,0)方向:北，
重復指令，機器人進入回圈:(0,0)——>(0,1)——>(- 1,1)——>(- 1,0)——>(0,0)，
在此基礎上，我們回傳true，
提示：
1 <= instructions.length <= 100instructions[i]僅包含'G', 'L', 'R'
解答思路一【Java】
時間0 ms 擊敗 100%
記憶體39.2 MB 擊敗 95.21%
這道題只要判斷機器人走完一圈會不會回到原地就行了
- 首先創建變數x和y，用于表示機器人的橫縱坐標位置，初始值都為0，
- 創建變數direction，用于表示機器人的方向，初始值為0，表示朝北方向，
- 遍歷指令字串中的每個字符，
- 對于每個字符，
- 如果是'G'，根據當前的方向向對應的坐標軸方向移動一步，
- 如果是'L'，將方向逆時針旋轉90度，
- 如果是'R'，將方向順時針旋轉90度，
- 判斷機器人的運動結果是否會回傳出發位置，如果滿足以下任意一個條件，回傳true；否則回傳false：
- 機器人停止后，橫縱坐標都為0；
- 機器人停止后，方向不再是向北方向，
class Solution {
public boolean isRobotBounded(String instructions) {
int x = 0;
int y = 0;
int direction = 0; // 0表示北，1表示東，2表示南，3表示西
for (char c : instructions.toCharArray()) {
if (c == 'G') {
if (direction == 0) {
y++;
} else if (direction == 1) {
x++;
} else if (direction == 2) {
y--;
} else if (direction == 3) {
x--;
}
} else if (c == 'L') {
direction = (direction + 3) % 4; // 逆時針旋轉90度，加3再取余
} else if (c == 'R') {
direction = (direction + 1) % 4; // 順時針旋轉90度，加1再取余
}
}
return (x == 0 && y == 0) || direction != 0;
}
}這段代碼涉及的知識點包括：
- 回圈結構：通過回圈遍歷指令字串中的每個字符，
- 條件判斷：通過條件判斷陳述句判斷指令字符的型別，并執行相應的操作，
- 變數的增減操作：根據當前的方向，增減對應的坐標軸上的值，
- 變數的取余操作：通過取余運算實作回圈遞增或遞減，實作方向的旋轉，
- 邏輯運算：通過邏輯運算子判斷機器人的運動結果是否回傳出發位置，
1672. 最富有客戶的資產總量
題目鏈接
1672. 最富有客戶的資產總量
題目描述
給你一個 m x n 的整數網格 accounts ，其中 accounts[i][j] 是第 i???????????? 位客戶在第 j 家銀行托管的資產數量，回傳最富有客戶所擁有的 資產總量 ，
客戶的 資產總量 就是他們在各家銀行托管的資產數量之和，最富有客戶就是 資產總量 最大的客戶，
示例 1：
輸入：accounts = [[1,2,3],[3,2,1]]
輸出：6
解釋：
第 1 位客戶的資產總量 = 1 + 2 + 3 = 6
第 2 位客戶的資產總量 = 3 + 2 + 1 = 6
兩位客戶都是最富有的，資產總量都是 6 ，所以回傳 6 ，示例 2：
輸入：accounts = [[1,5],[7,3],[3,5]]
輸出：10
解釋：
第 1 位客戶的資產總量 = 6 第 2 位客戶的資產總量 = 10 第 3 位客戶的資產總量 = 8 第 2 位客戶是最富有的，資產總量是 10示例 3：
輸入：accounts = [[2,8,7],[7,1,3],[1,9,5]]
輸出：17提示：
m == accounts.lengthn == accounts[i].length1 <= m, n <= 501 <= accounts[i][j] <= 100
解答思路一【Java】
時間0 ms 擊敗 100%
記憶體40.5 MB 擊敗 88.62%
- 遍歷二維陣列accounts，對每個客戶計算其資產總量，即對每個客戶的資產數量求和
- 比較每個客戶的資產總量，找到最大值，
- 回傳最大值作為最富有客戶的資產總量，
class Solution {
public int maximumWealth(int[][] accounts) {
int maxWealth = 0;
for (int[] customer : accounts) {
int wealth = 0;
for (int amount : customer) {
wealth += amount;
}
maxWealth = Math.max(maxWealth, wealth);
}
return maxWealth;
}
}知識點：
1. 二維陣列的遍歷方式，
2. 陣列的求和，
3. Math類的使用，
4. 變數賦值與比較，
1572. 矩陣對角線元素的和
題目鏈接
1572. 矩陣對角線元素的和
題目描述
給你一個正方形矩陣 mat，請你回傳矩陣對角線元素的和，
請你回傳在矩陣主對角線上的元素和副對角線上且不在主對角線上元素的和，
示例 1：
輸入：mat = [[1,2,3],
[4,5,6],
[7,8,9]]
輸出：25
解釋：對角線的和為：1 + 5 + 9 + 3 + 7 = 25
請注意，元素 mat[1][1] = 5 只會被計算一次，示例 2：
輸入：mat = [[1,1,1,1],
[1,1,1,1],
[1,1,1,1],
[1,1,1,1]]
輸出：8示例 3：
輸入：mat = [[5]]
輸出：5
提示：
n == mat.length == mat[i].length1 <= n <= 1001 <= mat[i][j] <= 100
解答思路一【Java】
時間1 ms 擊敗 25.37%
記憶體42.9 MB 擊敗 13.79%
解題思路：
1. 遍歷正方形矩陣mat的所有元素，
2. 判斷當前元素是否在主對角線上（即行索引和列索引相等）或者副對角線上（即行索引和列索引之和為矩陣長度減一），
3. 根據判斷結果，將對應元素的值加到對角線和上，
4. 回傳對角線和作為結果，
class Solution {
public int diagonalSum(int[][] mat) {
int sum = 0;
int n = mat.length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j || i + j == n - 1) {
sum += mat[i][j];
}
}
}
return sum;
}
}知識點：
1. 二維陣列的遍歷方式，
2. 陣列索引的使用，
3. 變數的賦值與比較，
工程日志
2023-07-05
- 簡單的模擬題基本上只要跟著題目給的描述走就可以了，因為步驟簡單，時空復雜度也難不到哪里去
- 編程基礎 0 到 1的題目整體上偏簡單，更考驗答題者的基本功，因此基礎好就顯得尤其重要
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/556629.html
標籤：其他
上一篇：nginx訪問日志過濾（多條件）
下一篇：返回列表