【算法】1920. 基于排列构建数组(java / c / c++ / python / go / rust)

简介: 给你一个 从 0 开始的排列 nums(下标也从 0 开始)。请你构建一个 同样长度 的数组 ans ,其中,对于每个 i(0 <= i < nums.length),都满足 ans[i] = nums[nums[i]] 。返回构建好的数组 ans 。从 0 开始的排列 nums 是一个由 0 到 nums.length - 1(0 和 nums.length - 1 也包含在内)的不同整数组成的数组。

1920. 基于排列构建数组:

给你一个 从 0 开始的排列 nums(下标也从 0 开始)。请你构建一个 同样长度 的数组 ans ,其中,对于每个 i(0 <= i < nums.length),都满足 ans[i] = nums[nums[i]] 。返回构建好的数组 ans 。

从 0 开始的排列 nums 是一个由 0 到 nums.length - 1(0 和 nums.length - 1 也包含在内)的不同整数组成的数组。

样例 1:

 输入:
     nums = [0,2,1,5,3,4]
输出:
    [0,1,2,4,5,3]
解释:
    数组 ans 构建如下:
    ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
        = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
        = [0,1,2,4,5,3]

样例 2:

输入:
    nums = [5,0,1,2,3,4]
输出:
    [4,5,0,1,2,3]
解释:
    数组 ans 构建如下:
    ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
        = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
        = [4,5,0,1,2,3]

提示:

  • 1 <= nums.length <= 1000
  • 0 <= nums[i] < nums.length
  • nums 中的元素 互不相同

分析

题目描述既是答案,直接新建一个同样大小的数组,遍历一遍,按顺序赋值即可。

但是这样需要占更多内容空间,而且单纯这样做,根本算不上算法吧?

怎样能做到不占用新的内存空间呢?提示中,每个数的范围都在[0,999]之间,这是个关键。


题解

java

按照题意的直接处理法

class Solution {
    public int[] buildArray(int[] nums) {
        final int n = nums.length;
        
        int[] ans = new int[n];
        
        for (int i = 0; i < n; ++i) {
            ans[i] = nums[nums[i]];
        }
        
        return ans;
    }
}

不开辟新的空间,直接在原数组处理

class Solution {
    public int[] buildArray(int[] nums) {
        final int n         = nums.length;
        final int highValue = 1000;

        // 将结果值附加到数组
        for (int i = 0; i < n; ++i) {
            // 将原值+结果
            // 一个值同时存储了原值和结果值
            nums[i] += highValue * (nums[nums[i]] % highValue);
        }

        // 将原值剔除,仅保留结果
        for (int i = 0; i < n; ++i) {
            nums[i] /= highValue;
        }

        return nums;
    }
}

c

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* buildArray(int* nums, int numsSize, int* returnSize){
    const int highValue = 1000;

    for (int i = 0; i < numsSize; ++i) {
        nums[i] += highValue * (nums[nums[i]] % highValue);
    }

    for (int i = 0; i < numsSize; ++i) {
        nums[i] /= highValue;
    }

    *returnSize = numsSize;

    return nums;
}

c++

class Solution {
public:
    vector<int> buildArray(vector<int>& nums) {
        const int highValue = 1000;
        int n = nums.size();

        for (int i = 0; i < n; ++i) {
            nums[i] += highValue * (nums[nums[i]] % highValue);
        }
        
        for (int i = 0; i < n; ++i) {
            nums[i] /= highValue;
        }

        return nums;
    }
};

python

from typing import List

class Solution:
    def buildArray(self, nums: List[int]) -> List[int]:
        highValue = 1000
        n = len(nums)
        for i in range(n):
            nums[i] += highValue * (nums[nums[i]] % highValue)
        for i in range(n):
            nums[i] //= highValue
        return nums

go

func buildArray(nums []int) []int {
    highValue := 1000
    n := len(nums)

    for i := 0; i < n; i++ {
        nums[i] += highValue * (nums[nums[i]] % highValue)
    }

    for i := 0; i < n; i++ {
        nums[i] /= highValue
    }

    return nums;
}

rust

impl Solution {
    pub fn build_array(nums: Vec<i32>) -> Vec<i32> {
        let mut nums = nums;
        
        let high_value = 1000;
        let n = nums.len();
        
        for i in 0..n {
            nums[i] += high_value * (nums[nums[i] as usize] % high_value);
        }

        for i in 0..n {
            nums[i] /= high_value;
        }

        return nums;
    }
}

原题传送门:https://leetcode-cn.com/problems/build-array-from-permutation/


非常感谢你阅读本文~
放弃不难,但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子:https://developer.aliyun.com/profile/sqd6avc7qgj7y 博客原创~

相关文章
|
21天前
|
存储 算法 量子技术
解锁文档管理系统高效检索奥秘:Python 哈希表算法探究
在数字化时代,文档管理系统犹如知识宝库,支撑各行各业高效运转。哈希表作为核心数据结构,通过哈希函数将数据映射为固定长度的哈希值,实现快速查找与定位。本文聚焦哈希表在文档管理中的应用,以Python代码示例展示其高效检索特性,并探讨哈希冲突解决策略,助力构建智能化文档管理系统。
|
23天前
|
算法 安全 网络安全
基于 Python 的布隆过滤器算法在内网行为管理中的应用探究
在复杂多变的网络环境中,内网行为管理至关重要。本文介绍布隆过滤器(Bloom Filter),一种高效的空间节省型概率数据结构,用于判断元素是否存在于集合中。通过多个哈希函数映射到位数组,实现快速访问控制。Python代码示例展示了如何构建和使用布隆过滤器,有效提升企业内网安全性和资源管理效率。
50 9
|
25天前
|
算法 Serverless 数据处理
从集思录可转债数据探秘:Python与C++实现的移动平均算法应用
本文探讨了如何利用移动平均算法分析集思录提供的可转债数据,帮助投资者把握价格趋势。通过Python和C++两种编程语言实现简单移动平均(SMA),展示了数据处理的具体方法。Python代码借助`pandas`库轻松计算5日SMA,而C++代码则通过高效的数据处理展示了SMA的计算过程。集思录平台提供了详尽且及时的可转债数据,助力投资者结合算法与社区讨论,做出更明智的投资决策。掌握这些工具和技术,有助于在复杂多变的金融市场中挖掘更多价值。
48 12
|
1月前
|
监控 算法 安全
内网桌面监控软件深度解析:基于 Python 实现的 K-Means 算法研究
内网桌面监控软件通过实时监测员工操作,保障企业信息安全并提升效率。本文深入探讨K-Means聚类算法在该软件中的应用,解析其原理与实现。K-Means通过迭代更新簇中心,将数据划分为K个簇类,适用于行为分析、异常检测、资源优化及安全威胁识别等场景。文中提供了Python代码示例,展示如何实现K-Means算法,并模拟内网监控数据进行聚类分析。
43 10
|
2月前
|
存储 算法 安全
控制局域网上网软件之 Python 字典树算法解析
控制局域网上网软件在现代网络管理中至关重要,用于控制设备的上网行为和访问权限。本文聚焦于字典树(Trie Tree)算法的应用,详细阐述其原理、优势及实现。通过字典树,软件能高效进行关键词匹配和过滤,提升系统性能。文中还提供了Python代码示例,展示了字典树在网址过滤和关键词屏蔽中的具体应用,为局域网的安全和管理提供有力支持。
62 17
|
14天前
|
运维 监控 算法
监控局域网其他电脑:Go 语言迪杰斯特拉算法的高效应用
在信息化时代,监控局域网成为网络管理与安全防护的关键需求。本文探讨了迪杰斯特拉(Dijkstra)算法在监控局域网中的应用,通过计算最短路径优化数据传输和故障检测。文中提供了使用Go语言实现的代码例程,展示了如何高效地进行网络监控,确保局域网的稳定运行和数据安全。迪杰斯特拉算法能减少传输延迟和带宽消耗,及时发现并处理网络故障,适用于复杂网络环境下的管理和维护。
|
15天前
|
编译器 Go
揭秘 Go 语言中空结构体的强大用法
Go 语言中的空结构体 `struct{}` 不包含任何字段,不占用内存空间。它在实际编程中有多种典型用法:1) 结合 map 实现集合(set)类型;2) 与 channel 搭配用于信号通知;3) 申请超大容量的 Slice 和 Array 以节省内存;4) 作为接口实现时明确表示不关注值。此外,需要注意的是,空结构体作为字段时可能会因内存对齐原因占用额外空间。建议将空结构体放在外层结构体的第一个字段以优化内存使用。
|
15天前
|
存储 缓存 安全
Go 语言中的 Sync.Map 详解:并发安全的 Map 实现
`sync.Map` 是 Go 语言中用于并发安全操作的 Map 实现,适用于读多写少的场景。它通过两个底层 Map(`read` 和 `dirty`)实现读写分离,提供高效的读性能。主要方法包括 `Store`、`Load`、`Delete` 等。在大量写入时性能可能下降,需谨慎选择使用场景。
|
15天前
|
存储 缓存 监控
企业监控软件中 Go 语言哈希表算法的应用研究与分析
在数字化时代,企业监控软件对企业的稳定运营至关重要。哈希表(散列表)作为高效的数据结构,广泛应用于企业监控中,如设备状态管理、数据分类和缓存机制。Go 语言中的 map 实现了哈希表,能快速处理海量监控数据,确保实时准确反映设备状态,提升系统性能,助力企业实现智能化管理。
28 3

热门文章

最新文章