这篇博客记录了作者在2021年1月14日至2月4日期间，参与LeetCode编程挑战的一些题目及解决方案。涉及的算法包括数组处理、字符串操作、数学计算、动态规划等。例如，解决可被5整除的二进制前缀问题，整数反转，最长公共前缀，有序数组中出现次数超过25%的元素等。博客内容详细介绍了每道题目的思路和代码实现。
2021/1/14
1
1018. 可被 5 整除的二进制前缀
给定由若干 0 和 1 组成的数组 A。我们定义 N_i：从 A[0] 到 A[i] 的第 i 个子数组被解释为一个二进制数（从最高有效位到最低有效位）。
返回布尔值列表 answer，只有当 N_i 可以被 5 整除时，答案 answer[i] 为 true，否则为 false。
- 思路：可被5整除的数字只跟该数字的最后一位数字（为0或5）有关系，于是不需要具体的算出二进制前缀对应的十进制整数是多少，下一个二进制前缀对应的十进制整数 = 上一次的结果左移一位（乘以2）的结果 + 这次的A[i]（0或者1，正好对应十进制的0或者1）的结果。
2
整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
class Solution {
public int reverse(int x) {
long a=0;
while(x!=0){
a=a*10+x%5;
x=x/10;
}
return(int)n==n?(int)n=0;
}
}
3
最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
纵向扫描时，从前往后遍历所有字符串的每一列，比较相同列上的字符是否相同，如果相同则继续对下一列进行比较，如果不相同则当前列不再属于公共前缀，当前列之前的部分为最长公共前缀。
2021/1/19
1.复写零
给你一个长度固定的整数数组 arr，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。
注意：请不要在超过该数组长度的位置写入元素。
- 思路：如果知道数组末尾有多少个元素被丢弃，就可以复制其他元素。丢弃的元素数量等于在原数组中添加的零的数量。通过向数组中添加零，将数组末尾的元素丢弃。
只要知道原始数组找中有多少个元素留下来，就可以从留下来元素的末尾开始复制。从末尾复制可以确保不会丢弃任何元素，因为只有末尾之后的元素才会被丢弃。
2.公交站间的距离
环形公交路线上有 n 个站，按次序从 0 到 n - 1 进行编号。我们已知每一对相邻公交站之间的距离，distance[i] 表示编号为 i 的车站和编号为 (i + 1) % n 的车站之间的距离。
环线上的公交车都可以按顺时针和逆时针的方向行驶。
返回乘客从出发点 start 到目的地 destination 之间的最短距离。
- 思路：先遍历，求出走一圈的距离，再算出开始站到结束站的距离，再用一圈的距离减去算出的距离，就等于逆时针时的距离
class Solution {
public int distanceBetweenBusStops(int[] distance, int start, int destination) {
if(distance==null||distance.length==0){
return 0;
}
int sum=0;
int dis=0;
for(int i=0;i<distance.length;i++){
sum=sum+distance[i];
if(i>=Math.min(start,destination)&&i<Math.max(start,destination)){
dis=dis+distance[i];
}
}
return Math.min(dis,sum-dis);
}
}
3左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
- 思路：将输入这个角标到这个字符串长度的角标截取出来，再将0到这个角标的截取出来，再输出出来
class Solution {
public String reverseLeftWords(String s, int n) {
return s.substring(n,s.length())+s.substring(0,n);
}
}
2021/1/23
1
有序数组中出现次数超过25%的元素
给你一个非递减的 有序 整数数组，已知这个数组中恰好有一个整数，它的出现次数超过数组元素总数的 25%。
请你找到并返回这个整数
示例：
输入：arr = [1,2,2,6,6,6,6,7,10]
输出：6
- 思路：因为这是有序数列，所以相等的数回在一起，所以我们只需要判断这个数向后的元素总数的25%的数，是否与这个数相等，相等返回这个数
class Solution {
public int findSpecialInteger(int[] arr) {
for (int i = 0, len = arr.length / 4; i < arr.length - len; i++)
if (arr[i] == arr[i + len])
return arr[i];
return arr[0];
}
}
2
“气球” 的最大数量
给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 “balloon”（气球）。
字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 “balloon”。
示例 1：
输入：text = “nlaebolko”
输出：1
示例 2：
输入：text = “loonbalxballpoon”
输出：2
- 思路：将字符串的字符遍历出来，再用switch去匹配，当出现气球中的每个字符时，每个字符的个数就加1，最都在计算‘ o ’‘ l ’的个数时除以2，最有在排序，返回第一个b出现的个数
class Solution {
public int maxNumberOfBalloons(String text) {
int[] a=new int [5];
for(char ch:text.toCharArray()) {
switch(ch){
case 'b': a[0]++; break;
case 'a': a[1]++; break;
case 'l': a[2]++; break;
case 'o': a[3]++; break;
case 'n': a[4]++; break;
}
}
a[2]/=2;
a[3]/=2;
Arrays.sort(a);
return a[0];
}
}
3
是否所有 1 都至少相隔 k 个元素
给你一个由若干 0 和 1 组成的数组 nums 以及整数 k。如果所有 1 都至少相隔 k 个元素，则返回 True ；否则，返回 False 。
示例 1：
输入：nums = [1,0,0,0,1,0,0,1], k = 2
输出：true
解释：每个 1 都至少相隔 2 个元素。
- 思路：「所有 11 都至少相隔 k 个元素」等价于「任意两个相邻的 11 都至少相隔 k 个元素」，因此我们只需要从左到右遍历数组，并记录上一个 11 出现的位置。
在遍历的过程中，如果我们找到了一个新的 11，就需要判断其与上一个 11 之间是否至少相隔 k 个元素。如果不满足要求，那么直接返回 False 作为答案，否则继续进行遍历
class Solution {
public boolean kLengthApart(int[] nums, int k) {
int n=nums.length;
int a=-1;
for(int i=0;i<n;++i){
if(nums[i]==1){
if(a!=-1&&i-a-1<k){
return false;
}
a=i;
}
}
return true;
}
}
2021/1/27
- 思路：先计数，记数字和字母的个数，差两个以上，比较哪个数大，就从0开始每次加2，自己走自己的，最后在放入一个新的数组
class Solution {
public int[] runningSum(int[] nums) {
for(int i=1;i<nums.length;i++){
nums[i]+=nums[i-1];
}
return nums;
}
}
2021/1/21
- 思路：先将用双指针，一个从开头，一个从结尾，在从后往前遍历字母
class Solution {
public String reverseOnlyLetters(String S) {
StringBuilder ans = new StringBuilder();
int j = S.length() - 1;
for (int i = 0; i < S.length(); ++i) {
if (Character.isLetter(S.charAt(i))) {
while (!Character.isLetter(S.charAt(j)))
j--;
ans.append(S.charAt(j--));
} else {
ans.append(S.charAt(i));
}
}
return ans.toString();
}
}
- 思路：新建一个数组，将数字对应的字母放到这个数组中
class Solution {
public String restoreString(String s, int[] indices) {
int length = s.length();
char[] result = new char[length];
for (int i = 0; i < length; i++) {
result[indices[i]] = s.charAt(i);
}
return new String(result);
}
}
- 思路：首先声明三个变量：
maxLength：用来记录数组rectangles中正方形的最长边长
(因为正方形边长大于0，所以初始值设为0即可)
tempLength：在遍历数组rectangles时临时保存每个正方形的边长
count：记录边长等于最长边长的正方形个数
(因为最少会有一个，所以初始值设为1)
然后遍历数组rectangles：
每次用tempLength和maxLength进行比较，
如果 tempLength 大于 maxLength，说明当前的正方形的边长是最大的，所以count变成1
如果 tempLength 等于 maxLength 说明当前边长最大的正方形个数加一即count++
如果 tempLength 小于 maxLength 说明当前边长最大的正方形个数不变即不用处理
作者：uive
链接：https://leetcode-cn.com/problems/number-of-rectangles-that-can-form-the-largest-square/solution/yi-ci-bian-li-ji-ke-jie-jue-by-uive-ixvj/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
2021/2/4
- 思路：先遍历棋盘找到车的坐标，再控制车移动，当遇到棋盘边缘停止，当遇到象也停止，当遇到卒就加一次数
class Solution {
public int numRookCaptures(char[][] board) {
int cnt = 0, st = 0, ed = 0;
int[] dx = {0, 1, 0, -1};
int[] dy = {1, 0, -1, 0};
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) {
if (board[i][j] == 'R') {
st = i;
ed = j;
break;
}
}
}
for (int i = 0; i < 4; ++i) {
for (int step = 0;; ++step) {
int tx = st + step * dx[i];
int ty = ed + step * dy[i];
if (tx < 0 || tx >= 8 || ty < 0 || ty >= 8 || board[tx][ty] == 'B') {
break;
}
if (board[tx][ty] == 'p') {
cnt++;
break;
}
}
}
return cnt;
}
}
不太懂
class Solution {
public String removeOuterParentheses(String S) {
StringBuilder sb = new StringBuilder();
int level = 0;
for (char c : S.toCharArray()) {
if (c == ')') --level;
if (level >= 1) sb.append(c);
if (c == '(') ++level;
}
return sb.toString();
}
}
class Solution {
private int getNext(int n) {
int totalSum = 0;
while (n > 0) {
int d = n % 10;
n = n / 10;
totalSum += d * d;
}
return totalSum;
}
public boolean isHappy(int n) {
Set<Integer> seen = new HashSet<>();
while (n != 1 && !seen.contains(n)) {
seen.add(n);
n = getNext(n);
}
return n == 1;
}
}
扫一扫
621
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
