Golang每日一练(leetDay0108) 灯泡开关I\II Bulb Switcher

简介: Golang每日一练(leetDay0108) 灯泡开关I\II Bulb Switcher

319. 灯泡开关 Bulb Switcher

初始时有 n 个灯泡处于关闭状态。第一轮,你将会打开所有灯泡。接下来的第二轮,你将会每两个灯泡关闭第二个。

第三轮,你每三个灯泡就切换第三个灯泡的开关(即,打开变关闭,关闭变打开)。第 i 轮,你每 i 个灯泡就切换第 i 个灯泡的开关。直到第 n 轮,你只需要切换最后一个灯泡的开关。

找出并返回 n 轮后有多少个亮着的灯泡。

示例 1:

输入:n =3

输出:1

解释:

初始时, 灯泡状态 [关闭, 关闭, 关闭].

第一轮后, 灯泡状态 [开启, 开启, 开启].

第二轮后, 灯泡状态 [开启, 关闭, 开启].

第三轮后, 灯泡状态 [开启, 关闭, 关闭].


你应该返回 1,因为只有一个灯泡还亮着。


示例 2:

输入:n = 0

输出:0


示例 3:

输入:n = 1

输出:1

提示:

  • 0 <= n <= 10^9

代码:

package main
import "fmt"
func bulbSwitch(n int) int {
  bulbs := make([]bool, n)
  for i := 0; i < n; i++ {
    for j := i; j < n; j += i + 1 {
      bulbs[j] = !bulbs[j]
    }
  }
  count := 0
  for _, b := range bulbs {
    if b {
      count++
    }
  }
  return count
}
func main() {
  fmt.Println(bulbSwitch(3))
  fmt.Println(bulbSwitch(0))
  fmt.Println(bulbSwitch(1))
}

输出:

1

0

1

其实本题只用一个公式就能解决:

```golang
func bulbSwitch(n int) int {
       return int(math.Sqrt(float64(n)))
}
```

672. 灯泡开关II Bulb Switcher ii

现有一个房间,墙上挂有 n 只已经打开的灯泡和 4 个按钮。在进行了 m 次未知操作后,你需要返回这 n 只灯泡可能有多少种不同的状态。

假设这 n 只灯泡被编号为 [1, 2, 3 ..., n],这 4 个按钮的功能如下:

  1. 将所有灯泡的状态反转(即开变为关,关变为开)
  2. 将编号为偶数的灯泡的状态反转
  3. 将编号为奇数的灯泡的状态反转
  4. 将编号为 3k+1 的灯泡的状态反转(k = 0, 1, 2, ...)

示例 1:

输入: n = 1, m = 1.

输出: 2

说明: 状态为: [开], [关]


示例 2:

输入: n = 2, m = 1.

输出: 3

说明: 状态为: [开, 关], [关, 开], [关, 关]


示例 3:

输入: n = 3, m = 1.

输出: 4

说明: 状态为: [关, 开, 关], [开, 关, 开], [关, 关, 关], [关, 开, 开].


注意:nm 都属于 [0, 1000].

代码:

package main
import "fmt"
func flipLights(n int, m int) int {
  init := make([]int, n)
  for i := range init {
    init[i] = 1
  }
  ops := make([][2]int, 4)
  ops[0] = [2]int{0, 1} // toggle all
  ops[1] = [2]int{1, 2} // toggle even
  ops[2] = [2]int{0, 2} // toggle odd
  ops[3] = [2]int{2, 2} // toggle every 3
  count := make(map[string]bool)
  count[serialize(init)] = true
  for i := 0; i < m; i++ {
    for j, op := range ops {
      if i == 0 && j == 0 {
        // first operation: toggle all
        for k := range init {
          init[k] ^= op[0]
        }
      } else {
        // other operations
        for k := op[0]; k < n; k += op[1] {
          init[k] ^= 1
        }
      }
      count[serialize(init)] = true
    }
  }
  return len(count)
}
func serialize(arr []int) string {
  res := make([]byte, len(arr))
  for i, v := range arr {
    if v == 0 {
      res[i] = '0'
    } else {
      res[i] = '1'
    }
  }
  return string(res)
}
func main() {
  fmt.Println(flipLights(1, 1))
  fmt.Println(flipLights(2, 1))
  fmt.Println(flipLights(3, 1))
}

输出:

2

3

4


🌟 每日一练刷题专栏 🌟

持续,努力奋斗做强刷题搬运工!

👍 点赞,你的认可是我坚持的动力!

🌟 收藏,你的青睐是我努力的方向!

评论,你的意见是我进步的财富!  

主页:https://hannyang.blog.csdn.net/

Rust每日一练 专栏

(2023.5.16~)更新中...

Golang每日一练 专栏

(2023.3.11~)更新中...

Python每日一练 专栏

(2023.2.18~2023.5.18)暂停更

C/C++每日一练 专栏

(2023.2.18~2023.5.18)暂停更

Java每日一练 专栏

(2023.3.11~2023.5.18)暂停更


目录
相关文章
|
安全 Java C++
2023-3-25 java选择题每日一练
2023-3-25 java选择题每日一练
137 1
CSDN每日一练(Java)--小艺的英文名
CSDN每日一练(Java)--小艺的英文名
|
Shell Linux 算法
Shell编程——弱数据类型的脚本语言快速入门指南
Shell编程——弱数据类型的脚本语言快速入门指南
207 0
Shell编程——弱数据类型的脚本语言快速入门指南
|
C++ Python Rust
Rust 重载运算符|复数结构的“加减乘除”四则运算
Rust 重载运算符|复数结构的“加减乘除”四则运算
286 0
Rust 重载运算符|复数结构的“加减乘除”四则运算
|
Go Linux Shell
Linux 终端命令之文件浏览(2) more
Linux 终端命令之文件浏览(2) more
190 0
Linux 终端命令之文件浏览(2) more
|
Linux
Linux 终端命令之文件浏览(1) cat
Linux 终端命令之文件浏览(1) cat
167 0
Linux 终端命令之文件浏览(1) cat
|
Shell 机器学习/深度学习 Linux
Linux 终端操作命令(2)内部命令
Linux 终端操作命令(2)内部命令
304 0
Linux 终端操作命令(2)内部命令
|
Go Python Rust
Rust 编程小技巧摘选(7)
Rust 编程小技巧摘选(7)
360 0
Rust 编程小技巧摘选(7)
|
2月前
|
JSON 网络协议 安全
【Java】(10)进程与线程的关系、Tread类;讲解基本线程安全、网络编程内容;JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念,进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位一般而言,进程包含如下三个特征。独立性动态性并发性。
201 1
|
2月前
|
JSON 网络协议 安全
【Java基础】(1)进程与线程的关系、Tread类;讲解基本线程安全、网络编程内容;JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念,进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位一般而言,进程包含如下三个特征。独立性动态性并发性。
226 1

推荐镜像

更多