2025-01-20：使所有元素都可以被 3 整除的最少操作数。用go语言，给定一个整数数组 nums，你可以通过对数组中任意一

福大大架构师每日一题

发布于 2025-01-22 11:17:15

2800

代码可运行

文章被收录于专栏：福大大架构师每日一题福大大架构师每日一题

运行总次数：0

代码可运行

2025-01-20：使所有元素都可以被 3 整除的最少操作数。用go语言，给定一个整数数组 nums，你可以通过对数组中任意一个元素进行加1或减1的操作。

在这些操作中，目标是使得数组内所有元素都能被3整除。请问你需要的最少操作次数是多少？

1 <= nums.length <= 50。

1 <= nums[i] <= 50。

输入：nums = [1,2,3,4]。

输出：3。

解释：

通过以下 3 个操作，数组中的所有元素都可以被 3 整除：

将 1 减少 1 。

将 2 增加 1 。

将 4 减少 1 。

答案2025-01-20：

chatgpt[1]

题目来自leetcode3190。

大体步骤如下：

1.遍历给定的整数数组 nums。

2.对于每个元素 x，检查它与3的余数是否为0。

3.如果 x 不能被3整除（即 x%3 != 0），则需要进行操作使其能够被3整除。

4.对于每个不满足条件的元素，计数器 ans 增加1。

5.返回最终操作次数 ans。

总的时间复杂度：

• 遍历整个数组的时间复杂度为 O(n)，其中 n 是数组的长度。
• 在每次遍历中执行常数时间的操作。
• 因此，总的时间复杂度为 O(n)。

总的额外空间复杂度：

• 除了输入数组 nums 和一个整型变量 ans 外，并没有使用任何额外的空间。
• 因此，总的额外空间复杂度为 O(1)。

Go完整代码如下：

package main

import (
    "fmt"
)

func minimumOperations(nums []int) (ans int) {
    for _, x := range nums {
        if x%3 != 0 {
            ans++
        }
    }
    return
}

func main() {
    nums := []int{1, 2, 3, 4}
    result := minimumOperations(nums)
    fmt.Println(result)
}

Rust完整代码如下：

fn minimum_operations(nums: &[i32]) -> i32 {
    let mut ans = 0;
    for &x in nums {
        if x % 3 != 0 {
            ans += 1;
        }
    }
    ans
}

fn main() {
    let nums = vec![1, 2, 3, 4];
    let result = minimum_operations(&nums);
    println!("{}", result);
}

C完整代码如下：

#include <stdio.h>

int minimumOperations(int nums[], int size) {
    int ans = 0;
    for (int i = 0; i < size; i++) {
        if (nums[i] % 3 != 0) {
            ans++;
        }
    }
    return ans;
}

int main() {
    int nums[] = {1, 2, 3, 4};
    int size = sizeof(nums) / sizeof(nums[0]);
    int result = minimumOperations(nums, size);
    printf("%d\n", result);
    return 0;
}

C++完整代码如下：

#include <iostream>
#include <vector>

int minimumOperations(const std::vector<int>& nums) {
    int ans = 0;
    for (int x : nums) {
        if (x % 3 != 0) {
            ans++;
        }
    }
    return ans;
}

int main() {
    std::vector<int> nums = {1, 2, 3, 4};
    int result = minimumOperations(nums);
    std::cout << result << std::endl;
    return 0;
}

Python完整代码如下：

# -*-coding:utf-8-*-

def minimum_operations(nums):
    ans = 0
    for x in nums:
        if x % 3 != 0:
            ans += 1
    return ans

if __name__ == "__main__":
    nums = [1, 2, 3, 4]
    result = minimum_operations(nums)
    print(result)

JavaScript完整代码如下：

function minimumOperations(nums) {
    let ans = 0;
    for (let x of nums) {
        if (x % 3 !== 0) {
            ans++;
        }
    }
    return ans;
}

const nums = [1, 2, 3, 4];
const result = minimumOperations(nums);
console.log(result);

Solidity完整代码如下：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MinimumOperations {
    // 存储结果
    uint public result;

    // 销毁合约前用于计算不为3的倍数数字的函数
    function minimumOperations(uint[] memory nums) public returns (uint) {
        uint ans = 0;
        for (uint i = 0; i < nums.length; i++) {
            if (nums[i] % 3 != 0) {
                ans++;
            }
        }
        result = ans; // 存储结果的状态变量
        return ans;   // 返回计算结果
    }
}