普通视图

发现新文章,点击刷新页面。
今天 — 2024年11月26日技术

[Python3/Java/C++/Go/TypeScript] 一题一解:一次遍历(清晰题解)

作者 lcbin
2024年11月26日 09:14

方法一:一次遍历

我们令 $k = 3$,表示交替组的长度为 $3$。

为了方便处理,我们可以将环展开成一个长度为 $2n$ 的数组,然后从左到右遍历这个数组,用一个变量 $\textit{cnt}$ 记录当前交替组的长度,如果遇到了相同的颜色,就将 $\textit{cnt}$ 重置为 $1$,否则将 $\textit{cnt}$ 加一。如果 $\textit{cnt} \ge k$,并且当前位置 $i$ 大于等于 $n$,那么就找到了一个交替组,答案加一。

遍历结束后,返回答案即可。

###python

class Solution:
    def numberOfAlternatingGroups(self, colors: List[int]) -> int:
        k = 3
        n = len(colors)
        ans = cnt = 0
        for i in range(n << 1):
            if i and colors[i % n] == colors[(i - 1) % n]:
                cnt = 1
            else:
                cnt += 1
            ans += i >= n and cnt >= k
        return ans

###java

class Solution {
    public int numberOfAlternatingGroups(int[] colors) {
        int k = 3;
        int n = colors.length;
        int ans = 0, cnt = 0;
        for (int i = 0; i < n << 1; ++i) {
            if (i > 0 && colors[i % n] == colors[(i - 1) % n]) {
                cnt = 1;
            } else {
                ++cnt;
            }
            ans += i >= n && cnt >= k ? 1 : 0;
        }
        return ans;
    }
}

###cpp

class Solution {
public:
    int numberOfAlternatingGroups(vector<int>& colors) {
        int k = 3;
        int n = colors.size();
        int ans = 0, cnt = 0;
        for (int i = 0; i < n << 1; ++i) {
            if (i && colors[i % n] == colors[(i - 1) % n]) {
                cnt = 1;
            } else {
                ++cnt;
            }
            ans += i >= n && cnt >= k ? 1 : 0;
        }
        return ans;
    }
};

###go

func numberOfAlternatingGroups(colors []int) (ans int) {
k := 3
n := len(colors)
cnt := 0
for i := 0; i < n<<1; i++ {
if i > 0 && colors[i%n] == colors[(i-1)%n] {
cnt = 1
} else {
cnt++
}
if i >= n && cnt >= k {
ans++
}
}
return
}

###ts

function numberOfAlternatingGroups(colors: number[]): number {
    const k = 3;
    const n = colors.length;
    let [ans, cnt] = [0, 0];
    for (let i = 0; i < n << 1; ++i) {
        if (i && colors[i % n] === colors[(i - 1) % n]) {
            cnt = 1;
        } else {
            ++cnt;
        }
        ans += i >= n && cnt >= k ? 1 : 0;
    }
    return ans;
}

时间复杂度 $O(n)$,其中 $n$ 为数组 $\textit{colors}$ 的长度。空间复杂度 $O(1)$。


有任何问题,欢迎评论区交流,欢迎评论区提供其它解题思路(代码),也可以点个赞支持一下作者哈😄~

Web3调试技巧

作者 蚂小蚁
2024年11月26日 08:10
前言 在开发 Web3 的过程中总会莫名其妙产生各种各样的问题,有时候一个问题会困扰自己很长时间,而 Web3 不像 Web2 一样能够找到一个热心同事手把手教你怎么解决,几乎全部要靠自己。就是因为这

理论 | 带你认识算法

作者 墨渊君
2024年11月26日 07:45
算法不仅是求职的关键技能, 还能提升逻辑思维能力, 帮助您解决复杂问题。文章通过对算法与程序的区别、排序算法的实例、时间复杂度与空间复杂度的分析, 深入浅出地介绍了算法的基本概念和应用...

理论 | 何谓数据结构?

作者 墨渊君
2024年11月26日 07:43
数据结构是存储和组织数据的方式, 决定了数据的顺序和关系。常见的数据结构包括数组、链表、栈、队列、哈希表、堆、树和图。根据数据的逻辑关系, 数据结构可分为线性和非线性; 根据物理存储方式....

FreeBuf早报 |网安AI将实现1548亿美元增长;猪宰割诈骗令30万人沦陷

2024年11月25日 18:13

全球动态

1.  研究人员使用BYOVD绕过防病毒保护的恶意软件

网络安全研究人员发现了一种新的恶意软件,利用一种叫做“携带你自己的脆弱驱动程序BYOVD”的技术解除安全保护,最终进入受感染的系统。 【外刊-

遍历计数,C 0ms

Problem: 100336. 交替组 I

[TOC]

思路

直接按题意遍历计数。

Code

执行用时分布0ms击败100.00%;消耗内存分布5.69MB击败100.00%

###C

int numberOfAlternatingGroups(int* colors, int colorsSize) {
    int ans = (colors[colorsSize - 2] != colors[colorsSize - 1] && colors[colorsSize - 1] != colors[0])
            + (colors[colorsSize - 1] != colors[0] && colors[0] != colors[1]);
    for (int i = 2; i < colorsSize; ++ i)
        if ((colors[i - 2] != colors[i - 1] && colors[i - 1] != colors[i])) ++ ans;
    return ans;
}

###Python3

class Solution:
    def numberOfAlternatingGroups(self, colors: List[int]) -> int:
        n, colors = len(colors), colors + colors[:2]
        return sum(colors[i] != colors[i + 1] != colors[i + 2] for i in range(n))

您若还有不同方法,欢迎贴在评论区,一起交流探讨! ^_^

↓ 点个赞,点收藏,留个言,再划走,感谢您支持作者! ^_^

每日一题-交替组 I🟢

2024年11月26日 00:00

给你一个整数数组 colors ,它表示一个由红色和蓝色瓷砖组成的环,第 i 块瓷砖的颜色为 colors[i] :

  • colors[i] == 0 表示第 i 块瓷砖的颜色是 红色 。
  • colors[i] == 1 表示第 i 块瓷砖的颜色是 蓝色 。

环中连续 3 块瓷砖的颜色如果是 交替 颜色(也就是说中间瓷砖的颜色与它 左边 和 右边 的颜色都不同),那么它被称为一个 交替 组。

请你返回 交替 组的数目。

注意 ,由于 colors 表示一个  ,第一块 瓷砖和 最后一块 瓷砖是相邻的。

 

示例 1:

输入:colors = [1,1,1]

输出:0

解释:

示例 2:

输入:colors = [0,1,0,0,1]

输出:3

解释:

交替组包括:

 

提示:

  • 3 <= colors.length <= 100
  • 0 <= colors[i] <= 1

交替组 I

2024年11月13日 10:16

方法一:模拟

思路

按照题意遍历数组 $\textit{colors}$ 的每个元素,判断其前一个元素和后一个元素是否都与当前元素不同,如果满足,则将结果加 $1$。注意瓷砖是环形的,则数组的首尾元素是相邻的。最后返回结果。

代码

###Python

class Solution:
    def numberOfAlternatingGroups(self, colors: List[int]) -> int:
        n = len(colors)
        res = 0
        for i in range(n):
            if colors[i] != colors[i - 1] and colors[i] != colors[(i + 1) % n]:
                res += 1
        return res

###Java

class Solution {
    public int numberOfAlternatingGroups(int[] colors) {
        int n = colors.length;
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (colors[i] != colors[(i - 1 + n) % n] && colors[i] != colors[(i + 1) % n]) {
                res += 1;
            }
        }
        return res;
    }
}

###C#

public class Solution {
    public int NumberOfAlternatingGroups(int[] colors) {
        int n = colors.Length;
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (colors[i] != colors[(i - 1 + n) % n] && colors[i] != colors[(i + 1) % n]) {
                res += 1;
            }
        }
        return res;
    }
}

###C++

class Solution {
public:
    int numberOfAlternatingGroups(vector<int>& colors) {
        int n = colors.size();
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (colors[i] != colors[(i - 1 + n) % n] && colors[i] != colors[(i + 1) % n]) {
                res += 1;
            }
        }
        return res;
    }
};

###Go

func numberOfAlternatingGroups(colors []int) int {
    n := len(colors)
    res := 0
    for i := 0; i < n; i++ {
        if colors[i] != colors[(i-1+n)%n] && colors[i] != colors[(i+1)%n] {
            res++
        }
    }
    return res
}

###C

int numberOfAlternatingGroups(int* colors, int colorsSize) {
    int res = 0;
    for (size_t i = 0; i < colorsSize; i++) {
        if (colors[i] != colors[(i - 1 + colorsSize) % colorsSize] && colors[i] != colors[(i + 1) % colorsSize]) {
            res += 1;
        }
    }
    return res;
}

###JavaScript

var numberOfAlternatingGroups = function(colors) {
    const n = colors.length;
    let res = 0;
    for (let i = 0; i < n; i++) {
        if (colors[i] !== colors[(i - 1 + n) % n] && colors[i] !== colors[(i + 1) % n]) {
            res++;
        }
    }
    return res;
};

###TypeScript

function numberOfAlternatingGroups(colors: number[]): number {
    const n = colors.length;
    let res = 0;
    for (let i = 0; i < n; i++) {
        if (colors[i] !== colors[(i - 1 + n) % n] && colors[i] !== colors[(i + 1) % n]) {
            res++;
        }
    }
    return res;
};

###Rust

impl Solution {
    pub fn number_of_alternating_groups(colors: Vec<i32>) -> i32 {
        let n = colors.len();
        let mut res = 0;
        for i in 0..n {
            if colors[i] != colors[(i + n - 1) % n] && colors[i] != colors[(i + 1) % n] {
                res += 1;
            }
        }
        res
    }
}

复杂度分析

  • 时间复杂度:$O(n)$。

  • 空间复杂度:$O(1)$。

滑动窗口

作者 tsreaper
2024年7月7日 01:31

解法:滑动窗口

枚举组的开头,那么组中间的 $(k - 2)$ 个元素都需要满足“与两边的颜色不同”的条件。预处理哪些元素和两边的颜色不同,再用滑动窗口统计中间的 $(k - 2)$ 个元素中,有几个满足该条件即可。复杂度 $\mathcal{O}(n)$。

参考代码(c++)

###cpp

class Solution {
public:
    int numberOfAlternatingGroups(vector<int>& colors, int K) {
        int n = colors.size();
        // 预处理哪些元素与两边颜色不同
        int f[n];
        for (int i = 0; i < n; i++) {
            int x = colors[(i - 1 + n) % n];
            int y = colors[i];
            int z = colors[(i + 1) % n];
            if (x != y && y != z) f[i] = 1;
            else f[i] = 0;
        }

        // 滑动窗口
        int sm = 0;
        for (int i = 1; i + 1 < K; i++) sm += f[i];
        int ans = 0;
        for (int i = 0; i < n; i++) {
            if (sm == K - 2) ans++;
            sm -= f[(i + 1) % n];
            sm += f[(i + K - 1) % n];
        }
        return ans;
    }
};
昨天 — 2024年11月25日技术
❌
❌