资讯详情

【算法leetcode每日一练】2120. 执行所有后缀指令

文章目录

  • 2120. 执行所有后缀指令：
  • 样例 1：
  • 样例 2：
  • 样例 3：
  • 提示：
  • 分析
  • 题解
    • java
    • c
    • c
    • python
    • go
    • rust
    • typescript
  • 原题传送门：https://leetcode-cn.com/problems/execution-of-all-suffix-instructions-staying-in-a-grid/

2120. 执行所有后缀指令：

现有一个 n x n 大小网格，左上角单元格坐标 (0, 0) ，单元格坐标在右下角 (n - 1, n - 1) 。给你整数 n 和整数数组 startPos ，其中 startPos = [ s t a r t r o w start_{row} startrow, s t a r t c o l start_{col} startcol] 机器人最初的坐标是坐标 ( s t a r t r o w start_{row} startrow, s t a r t c o l start_{col} startcol​) 的单元格上。

另给你一个长度为 m 、下标从 0 开始的字符串 s ，其中 s[i] 是对机器人的第 i 条指令：'L'（向左移动），'R'（向右移动），'U'（向上移动）和 'D'（向下移动）。

机器人可以从 s 中的任一第 i 条指令开始执行。它将会逐条执行指令直到 s 的末尾，但在满足下述条件之一时，机器人将会停止：

  • 下一条指令将会导致机器人移动到网格外。
  • 没有指令可以执行。

返回一个长度为 m 的数组 answer ，其中 answer[i] 是机器人从第 i 条指令 ，可以执行的 。

样例 1：

在这里插入图片描述

输入：
	n = 3, startPos = [0,1], s = "RRDDLU"
	
输出：
	[1,5,4,3,1,0]
	
解释：
	机器人从 startPos 出发，并从第 i 条指令开始执行：
	- 0: "RRDDLU" 在移动到网格外之前，只能执行一条 "R" 指令。
	- 1:  "RDDLU" 可以执行全部五条指令，机器人仍在网格内，最终到达 (0, 0) 。
	- 2:   "DDLU" 可以执行全部四条指令，机器人仍在网格内，最终到达 (0, 0) 。
	- 3:    "DLU" 可以执行全部三条指令，机器人仍在网格内，最终到达 (0, 0) 。
	- 4:     "LU" 在移动到网格外之前，只能执行一条 "L" 指令。
	- 5:      "U" 如果向上移动，将会移动到网格外。

样例 2：

输入：
	n = 2, startPos = [1,1], s = "LURD"
	
输出：
	[4,1,0,0]
	
解释：
	- 0: "LURD"
	- 1:  "URD"
	- 2:   "RD"
	- 3:    "D"

样例 3：

输入：
	n = 1, startPos = [0,0], s = "LRUD"
	
输出：
	[0,0,0,0]
	
解释：
	无论机器人从哪条指令开始执行，都会移动到网格外。

提示：

  • points.length == n
  • m == s.length
  • 1 <= n, m <= 500
  • startPos.length == 2
  • 0 <= startrow, startcol < n
  • s 由 ‘L’、‘R’、‘U’ 和 ‘D’ 组成

分析

  • 面对这道算法题目，二当家的陷入了沉思。
  • 看起来模拟就可以了，只是如何码得漂亮一点。

题解

java

class Solution { 
        
    public int[] executeInstructions(int n, int[] startPos, String s) { 
        
        // 命令长度
		final int l = s.length();
		// 结果
        int[] ans = new int[l];
		for (int i = 0; i < l; ++i) { 
        
			int r = startPos[0];
			int c = startPos[1];
            ans[i] = l - i;
			for (int j = i; j < l; ++j) { 
        
				char ch = s.charAt(j);
				switch(ch) { 
        
					case 'L':
						c -= 1;
						break;
					case 'R':
						c += 1;
						break;
					case 'U':
						r -= 1;
						break;
					case 'D':
						r += 1;
						break;
				}
				if (r < 0 || r >= n || c < 0 || c >= n) { 
        
					ans[i] = j - i;
					break;
				}
			}
			
		}
		return ans;
    }
}

c

/** * Note: The returned array must be malloced, assume caller calls free(). */
int* executeInstructions(int n, int* startPos, int startPosSize, char * s, int* returnSize){ 
        
    *returnSize = strlen(s);
    int* ans = malloc(*returnSize * sizeof (int));
    for (int i = 0; i < *returnSize; ++i) { 
        
        int r = startPos[0];
        int c = startPos[1];
        ans[i] = *returnSize - i;
        for (int j = i; j < *returnSize; ++j) { 
        
            char ch = s[j];
            switch(ch) { 
        
                case 'L':
                    c -= 1;
                    break;
                case 'R':
                    c += 1;
                    break;
                case 'U':
                    r -= 1;
                    break;
                case 'D':
                    r += 1;
                    break;
            }
            if (r < 0 || r >= n || c < 0 || c >= n) { 
        
                ans[i] = j - i;
                break;
            }
        }
    }
    return ans;
}

c++

class Solution { 
        
public:
    vector<int> executeInstructions(int n, vector<int>& startPos, string s) { 
        
        // 命令长度
		const int l = s.size();
		// 结果
        vector<int> ans;
		for (int i = 0; i < l; ++i) { 
        
			int r = startPos[0];
			int c = startPos[1];
			int cnt = l - i;
			for (int j = i; j < l; ++j) { 
        
				char ch = s[j];
				switch(ch) { 
        
					case 'L':
						c -= 1;
						break;
					case 'R':
						c += 1;
						break;
					case 'U':
						r -= 1;
						break;
					case 'D':
						r += 1;
						break;
				}
				if (r < 0 || r >= n || c < 0 || c >= n) { 
        
					cnt = j - i;
					break;
				}
			}
            ans.push_back(cnt);
		}
		return ans;
    }
};

python

class Solution:
    def executeInstructions(self, n: int, startPos: List[int], s: str) -> List[int]:
        # 命令长度
        l = len(s)
		# 结果
        ans = list()
        for i in range(l):
            r = startPos[0]
            c = startPos[1]
            cnt = l - i
            for j in range(i, l):
                ch = s[j]
                if ch == 'L':
                    c -= 1
                elif ch == 'R':
                    c += 1
                elif ch == 'U':
                    r -= 1
                else:
                    r += 1
                if r < 0 or r >= n or c < 0 or c >= n:
                    cnt = j - i
                    break
            ans.append(cnt)
        return ans

go

func executeInstructions(n int, startPos []int, s string) []int { 
        
    ans := []int{ 
        }
    l := len(s)
	for i := 0; i < l; i++ { 
        
        r,c := startPos[0],startPos[1]
        cnt := l - i
        for j := i; j < l; j++ { 
        
			ch := s[j]
            if ch == 'L' { 
        
				c -= 1
			} else if ch == 'R' { 
        
				c += 1
			} else if ch == 'U' { 
        
				r -= 1
			} else { 
        
				r += 1
			}
			if r < 0 || r >= n || c < 0 || c >= n { 
        
				cnt = j - i
				break
			}
        }
        ans = append(ans, cnt)
    }
	return ans
}

rust

impl Solution { 
        
    pub fn execute_instructions(n: i32, start_pos: Vec<i32>, s: String) -> Vec<i32> { 
        
        let mut ans = Vec::new();
        (0..s.len()).for_each(|i|{ 
        
            let mut r = start_pos[0];
            let mut c = start_pos[1];
            let mut cnt = s.len() - i;
            for j in i..s.len() { 
        
                match s.as_bytes()[j] as char { 
        
                    'L'=>{ 
        c -= 1;},
                    'R'=>{ 
        c += 1;},
                    'U'=>{ 
        r -= 1;},
                    _=>{ 
        r += 1;},
                };
                if r < 0 || r >= n || c < 0 || c >= n { 
        
                    cnt = j - i;
                    break;
                }
            }
            ans.push(cnt as i32);
        });
        ans
    }
}

typescript

function executeInstructions(n: number, startPos: number[], s: string): number[] { 
        
    // 命令长度
    let l = s.length;
    // 结果
    let ans = [];
    for (let i = 0; i < l; ++i) { 
        
        let r = startPos[0];
        let c = startPos[1];
        ans[i] = l - i;
        for (let j = i; j < l; ++j) { 
        
            let ch = s.charAt(j);
            switch(ch) { 
        
                case 'L':
                    c -= 1;
                    break;
                case 'R':
                    c += 1;
                    break;
                case 'U':
                    r -= 1;
                    break;
                case 'D':
                    r += 1;
                    break;
            }
            if (r < 0 || r >= n || c < 0 || c >= n) { 
        
                ans[i] = j - i;
                break;
            }
        }
        
    }
    return ans;
};

原题传送门：https://leetcode-cn.com/problems/execution-of-all-suffix-instructions-staying-in-a-grid/

非常感谢你阅读本文~ 欢迎【👍点赞】【⭐收藏】【📝评论】~ 放弃不难，但坚持一定很酷~ 希望我们大家都能每天进步一点点~ 本文由 二当家的白帽子：https://le-yi.blog.csdn.net/ 博客原创~

标签： s3urd交流电压变送器

锐单商城拥有海量元器件数据手册、 IC替代型号，打造 电子元器件IC百科大全！

锐单商城 - 一站式电子元器件采购平台