数组中子数组和为固定值的题目汇总

最新推荐文章于 2021-12-23 19:29:46 发布
最新推荐文章于 2021-12-23 19:29:46 发布
阅读量998 收藏
点赞数
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longlovefilm/article/details/79249084
版权

开头附件一部分数组去重的知识

 

C++中数组/Vector中去除重复元素

unique函数是一个去重函数，去除相邻中的重复元素（只留一个）。

其中，最关键的是：并不是删除并不是把重复的元素删除，而是全部放倒数组的后面。

因为，unique只是去除（相邻）的重复元素，因此，为了去除重复的元素，应该，首先对数组/Vector进行排序，这样保证重复元素在相邻的位置。

unique函数，返回的是去重后的尾地址。

因此对于一个内容为{2, 2, 5, 5, 6}的vector，执行unique函数以后，vector大小并没有改变，只不过顺序变成了{2, 5, 6, 2, 5}，并且函数的返回值为:3。

此时需要删除重复元素，只需要将后面的数据全部删除即可。

排序函数(sort)和去重函数都在<algorithm>头文件中。

复制代码 
 1 #include <iostream>
 2 #include <algorithm>
 3 #include <vector>
 4 using namespace std;
 5 
 6 
 7 int main() {
 8     vector<int> v;
 9     cout << "Number of vector's element : " << endl;
10     int number;
11     cin >> number;
12     for (int i = 0; i < number; i++) {
13         int temp;
14         cin >> temp;
15         v.push_back(temp);
16     }
17     sort(v.begin(),v.end());
18     v.erase(unique(v.begin(), v.end()), v.end());
19     for (int i = 0; i < v.size(); i++) {
20         cout << v[i] << " ";
21     }
22     cout << endl;
23     return 0;
24 }
复制代码

unique()函数将重复的元素放到vector的尾部然后返回指向第一个重复元素的迭代器再用erase函数擦除从这个元素到最后元素的所有的元素

自己写的去重函数！

int QuChong(int *nums, int len)
{
    sort(nums, nums + len);
    int i = 0, j = 0;
    for ( i = 0; i < len-1; i++)
    {
        while (nums[i] == nums[i + 1])
        {
            i++;
        }
        nums[j++] = nums[i];
    }
    return j;
}
 int main()
 {
     int nums[10] = { 1, 1,8,2, 3, 4, 5, 6, 7, 8 };
     cout << QuChong(nums,10) << endl;
     cout << unique(nums, nums + 10)-nums << endl;;
     system("pause");
     return 0;
 } 

题目表

1）输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对，输出任意一对既可。

2）排序不重复的数组求所有对数和为固定值sum的所有对数！

3）排序不重复的数组求所有对数差值为固定值的所有对数！

3-1）给出n和k，然后给出n个数，求出数组里面两两数的差为k有几对，数组排序及是否重复不限制。

4）输入一个非递增非排序的数组（可能有重复数字）和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对，输出所有可能对数，不能重复。

5）输入一个正数S，打印出所有和为S的连续正数序列，至少包含两个数；例如输入15，应该输出（1,2,3,4,5）（4,5,6）（7,8）。

6）回溯法求数组中和为定值的子数组的组合！

7）求连续子数组的最大和问题！

8）股票最大收益问题，求数组中后面最大值（卖出）减去前面最小值（买入）的最大收益差值（2020-12-10）

 

 

 

 

文章正式开始！！

 

1）输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对，输出任意一对既可。

java版本：

public class Test1 {
    public static ArrayList<Integer> FindNumbersWithSum(int[] array, int sum) {
        ArrayList<Integer> list = new ArrayList<>();
        if (array == null || array.length < 2) {
            return list;
        }
        int begin = 0, end = array.length - 1;
        while (begin < end) {
            if ((array[begin] + array[end]) == sum) {
                list.add(array[begin]);
                list.add(array[end]);
                break;
            } else if ((array[begin] + array[end]) > sum) {
                end--;
            } else {
                begin++;
            }
        }
        return list;
    }

    public static void main(String[] args) {
        int[] str ={1,2,3,4};
        System.out.println(FindNumbersWithSum(str, 5));

    }
}

c++版本：

bool FindTwoNumsWithSum(int *nums, int sum, int len, vector<int> &res)
{
    bool found = false;
    if (len < 1 || nums == NULL)
        return found;
    int begin = 0, end = len - 1;
    while (begin < end)
    {
        long long cursum = nums[begin] + nums[end];
        if (cursum == sum)
        {
            res.push_back(nums[begin]);
            res.push_back(nums[end]);
            found = true;
            break;
        }
        if (cursum>sum)
        {
            end--;
        }
        else
            begin++;
    }
    return found;
}

 int main()
 {
     int nums[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
     int len = 8;
     int sum = 9;
     vector<int> res;
     FindTwoNumsWithSum(nums, sum, len, res);
     cout << res[0] << res[1] << endl;
    // MainFun(nums, len,  sum);
     system("pause");
     return 0;
 }

2）排序不重复的数组求所有对数和为固定值sum的所有对数！

java版本：

public class TwoTuple<A, B> {

    public final A first;

    public final B second;

    public TwoTuple(A a, B b){
        first = a;
        second = b;
    }

    public String toString(){
        return "(" + first + ", " + second + ")";
    }

}
public class Test1 {
    public static ArrayList<TwoTuple> FindAllNumbersWithSum(int[] array, int sum) {
        ArrayList<TwoTuple> list = new ArrayList<>();
        if (array == null || array.length < 2) {
            return list;
        }
        int begin = 0, end = array.length - 1;
        while (begin < end) {
            if ((array[begin] + array[end]) == sum) {
                TwoTuple<Integer, Integer> tuple = new TwoTuple<>(array[begin], array[end]);
                list.add(tuple);
                begin++;
                end--;
            } else if ((array[begin] + array[end]) > sum) {
                end--;
            } else {
                begin++;
            }
        }
        return list;
    }

    public static void main(String[] args) {
        int[] str ={1,2,3,4};
        ArrayList<TwoTuple> twoTuples = FindAllNumbersWithSum(str, 5);
        for(TwoTuple var:twoTuples){
            System.out.println(var.first+"  "+var.second);
        }
    }
}

c++版本：

void dualSum(int arr[], int len, int sum)
{
    int low = 0;
    int high = len - 1;

    while (low<high)
    {
        while (arr[high] >= sum)
        {
            high--;
        }

        if (arr[low] + arr[high]>sum)
            high--;
        else if (arr[low] + arr[high]<sum)
            low++;
        else
        {
            cout << arr[low] << " + " << arr[high] << " = " << sum << endl;
            high--; low++;//仅仅是如果题目要求数组没有重复元素的时候才会成立！
        }
    }
}
int main()
{  
    int arr2[] = { 1,2,3,4,5,6 };
    int len = 6;
    int sum = 7;
    dualSum(arr2, len, sum);
    system("pause");
    return 0;
}

3）排序不重复的数组求所有对数差值为固定值的所有对数！

void dualSum(int arr[], int len, int k)
{
    int low = 0;
    int high = 0;
    while (low<len)
    {        
        if (arr[high] -arr[low]>k)
            low++;
        else if (arr[high] - arr[low]<k)
            high++;
        else
        {
            cout << arr[low] << " chavalue" << arr[high] << " = " << k << endl;
            high++;//仅仅是如果题目要求数组没有重复元素的时候才会成立！
        }
    }
}
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 10 };
    int len = 6;
    int k = 2;
    dualSum(arr, len, k);
    system("pause");
    return 0;

}

3-1）给出n和k，然后给出n个数，求出数组里面两两数的差为k有几对，数组排序及是否重复不限制。

public static int findPairs2(int[] nums, int k) {
    // k小于0无意义
    int count = 0;
    if (nums == null || nums.length == 0 || k < 0)
        return 0;
    //这里使用了HashMap可以达到去重的目的
    Map<Integer, Integer> map = new HashMap<>();
    for (int num : nums){
        if(map.containsKey(num)){
            map.put(num,map.get(num)+1);
        }else{
            map.put(num,1);
        }
    }
    for(Integer key:map.keySet()){
        if(k==0&&map.get(key)>=2){
            count++;
        }
        if(k>0&&map.containsKey(key+k)){
            count++;
        }
    }
    return count;
}

int NumChaValue(int * arr,int num, int k)
{
    multiset<int> all;
    for (int i = 0; i < num; i++)
    {
        all.insert(arr[i]);
    }
    multiset<int>::iterator ite = all.begin();
    int res = 0;
    for (; ite != all.end(); ite++)
    {
        if (all.count((*ite) + k)>0)
        {
            res += all.count((*ite) + k);
        }
    }
    return res;
}


int main() {
    int arr[] = {1,3,3,3 ,5};
    //cout << sizeof(arr) / sizeof(arr[0]) << endl;
    int num = sizeof(arr) / sizeof(arr[0]);
    int k = 2;
    cout << NumChaValue( arr,  num, k) << endl;
    system("pause");
    return 0;
}

4）输入一个非递增非排序的数组（可能有重复数字）和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对，输出所有可能对数，不能重复。

方法一思路： 用N减去每个元素得到另一个数组b，嵌套循环找到a与b中值相同而位置不同的元素对；空间复杂度2N，时间复杂度O(N^2)。（时间复杂度较高，相当于暴力解法）

void CalcTwoSum(int *nums, int len, int sum, vector<vector<int>> &vec)
{
    int *numsB= new int[len];
    for (int i = 0; i < len; i++)
    {
        numsB[i] = sum - nums[i];
    }
    int index = 0;
    for (int i = 0; i < len; i++)
    {
        int find = numsB[i];
        for (int j = i + 1; j < len; j++)
        {
            if (nums[j] == find)
            {
                cout << numsB[i] << " + " << nums[i] << endl;
                vector<int> tmp;
                tmp.push_back(numsB[i]);
                tmp.push_back(nums[i]);
                vec.push_back(tmp);//注意vector<vector<int>>的赋值方法，不能像二维数组那样单独赋值，需要建一个临时vector<int>tmp来赋值处理！！
            }
                
        }
    }
}


int QuChong(int *nums, int len)
{
    sort(nums, nums + len);
    int i = 0, j = 0;
    for ( i = 0; i < len-1; i++)
    {
        while (nums[i] == nums[i + 1])
        {
            i++;
        }
        nums[j++] = nums[i];
    }
    return j;
}
 int main()
 {
     int nums[10] = { 1, 1,8,2, 3, 4, 5, 6, 7, 8 };
     int len = QuChong(nums, 10);
     int sum = 9;
     vector<vector<int>> vec;
     CalcTwoSum(nums, len, sum,vec);

     system("pause");
     return 0;
 }

 

5）输入一个正数S，打印出所有和为S的连续正数序列，至少包含两个数；例如输入15，应该输出（1,2,3,4,5）（4,5,6）（7,8）。

我的做法，好理解一些

void PrintContinuousSequence(int small, int big);

void FindContinuousSequence(int sum)
{
    if (sum < 3)
        return;

    int small = 1;
    int big = 2;
    int middle = (1 + sum) / 2;
    int curSum = small + big;

    while (small < middle)
    {
        if (curSum == sum)
        {
            PrintContinuousSequence(small, big);
            big++;
            curSum += big;//这个千万不要漏掉，因为要求满足和为sum的所有组合，否则就停掉了！
        }
        else if (curSum > sum)
        {
            curSum -= small;
            small++;
        }
        else
        {
            big++;
            curSum += big;
        }
        
    }
}

void PrintContinuousSequence(int small, int big)
{
    for (int i = small; i <= big; ++i)
        printf("%d ", i);

    printf("\n");
}
int main()
{

    FindContinuousSequence(15);


    system("pause");
    return 0;
}

剑指offer做法

void PrintContinuousSequence(int small, int big);

void FindContinuousSequence(int sum)
{
    if(sum < 3)
        return;

    int small = 1;
    int big = 2;
    int middle = (1 + sum) / 2;
    int curSum = small + big;

    while(small < middle)
    {
        if(curSum == sum)
            PrintContinuousSequence(small, big);

        while(curSum > sum && small < middle)
        {
            curSum -= small;
            small ++;

            if(curSum == sum)
                PrintContinuousSequence(small, big);
        }

        big ++;
        curSum += big;
    }
}

void PrintContinuousSequence(int small, int big)
{
    for(int i = small; i <= big; ++ i)
        printf("%d ", i);

    printf("\n");
}

6）回溯法求数组中和为定值的组合（方法2 感觉好理解一些）

方法1

void sumn(vector<int> &A, int start, int end, int sum, vector<int> &tmp, vector<vector<int>> &res);
void MainFun(int *nums, int len, int sum)
{
    vector<int> A;
    int start = 0,end=len-1;
    for (int i = 0; i < len; i++)
        A.push_back(nums[i]);
    vector<int> tmp;
    vector<vector<int>> res;
    sumn(A, start, end, sum, tmp, res);
    for (int i = 0; i < res.size(); i++)
    {
        for (unsigned int j = 0; j < res[i].size(); j++)
        {
            cout << res[i][j] << " ";
        }
        cout << endl;
    }
}


void sumn(vector<int> &A, int start, int end, int sum, vector<int> &tmp, vector<vector<int>> &res){
    if (start == end && sum == 0)
    {
        res.push_back(tmp);
    }
    else if (start == end)
        return;
    else
    {
        if (sum >= A[start])
        {
            tmp.push_back(A[start]);
            sumn(A, start + 1, end, sum - A[start], tmp, res);//求start后面和为sum - A[start]的组合
            tmp.pop_back();//需要将tmp临时数组恢复原样
        }
        sumn(A, start + 1, end, sum, tmp, res);//依次递增start求数组后面除了含有start前面数字的子数组组合。
    }
}

 int main()
 {
     int nums[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
     int len = 8;
     int sum = 15;
     MainFun(nums, len,  sum);
     system("pause");
     return 0;
 }

方法2

void Combination_helper(vector<int> array, int begin, int &current, int target, vector<int>&path)
{
    if (begin >= array.size())
        return;
    current += array[begin];
    path.push_back(array[begin]);
    if (current == target)
    {
        for (int i = 0; i < path.size(); i++)
            cout << path[i] << ' ';
        cout << endl;
    }
    Combination_helper(array, begin + 1, current, target, path);
    path.pop_back();
    current -= array[begin];

    /*
    int j;
    for (j = begin + 1; j < array.size();)
    {
        if (array[j] == array[begin])
            j++;
        else
            break;
    }
    Combination_helper(array, j, current, target, path);
    *///这个是去掉重复值的作用，看看要求里面有没有去重的题目要求
}
int main()
{
    vector<int>array({ 1, 2, 2, 3, 4, 4, 5, 5, 6, 6, 7 });
    //vector<int>array({ 1, 2, 3});
    vector<int>path;
    int current = 0;
    Combination_helper(array, 0, current, 10, path);
    system("pause");
    return 0;

}

 

7）求连续子数组的最大和问题（剑指offer T31）并且输出这个最大的子数组ResMaxInt

java版本

public class LCS {
    public static List<Integer> getLCSList(List<Integer> arr) {
        ArrayList<Integer> maxArr = new ArrayList<>();
        ArrayList<Integer> tmpArr = new ArrayList<>();
        int max = 0, currSum = 0;
        if (null == arr || arr.size() <= 0)
            return maxArr;
        for (int i = 0; i < arr.size(); i++) {
            if(currSum <= 0){
                currSum = arr.get(i);
                tmpArr.clear();
                tmpArr.add(arr.get(i));
            }else{
                currSum+=arr.get(i);
                tmpArr.add(arr.get(i));
            }
            if(currSum>=max){
                max = currSum;
                maxArr.clear();
                maxArr = (ArrayList<Integer>)tmpArr.clone();//也可以单个循环赋值给maxArr
            }
        }
        return maxArr;
    }

    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(2);
        arr.add(3);
        arr.add(-100);
        arr.add(100);
        arr.add(1);
        List<Integer> lcsList = getLCSList(arr);
        System.out.println(lcsList);
    }
}

c++版本

int maxSubInt(int arr[], int length, vector<int> &ResMaxInt)
{
    if (NULL == arr || length <= 0)
        return 0;
    int TmpSum = 0;
    vector<int> TmpMaxInt;
    int ResSum = 0;
    for (int i = 0; i < length; i++)
    {
        if (TmpSum <= 0)
        {
            TmpSum = arr[i];
            vector<int> TmporaryMaxInt;
            TmporaryMaxInt.push_back(arr[i]);
            TmpMaxInt = TmporaryMaxInt;
        }
        else
        {
            TmpSum += arr[i];
            TmpMaxInt.push_back(arr[i]);
        }
        if (TmpSum>ResSum)
        {
            ResSum = TmpSum;
            ResMaxInt = TmpMaxInt;
        }
    }
    return ResSum;
}
int main() {
    int arr[] = { 1, -2, 3, 10, -4, 7, 2, -5 };
    int length = sizeof(arr) / sizeof(arr[0]);
    vector<int> ResMaxInt;
    cout << maxSubInt(arr,  length, ResMaxInt) << endl;
    system("pause");
    return 0;
}
 

8）股票最大收益问题，求数组中后面最大值（卖出）减去前面最小值（买入）的最大收益差值（2020-12-10）

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0

 

class Solution {
    public int maxProfit(int[] prices) {
        int len;
        if(prices == null || (len=prices.length) <= 1)
            return 0;
        int max_profit = 0;
        int base_num = prices[0];
        for(int i = 1;i < len;i++) {
            if(prices[i] > base_num)
                max_profit = Math.max(max_profit,prices[i] - base_num);
            else 
                base_num = prices[i];
        }
        return max_profit;
    }
}

 

 

 

 

 

 

 

 

longlovefilm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组中子数组最大累计和
12-21
在编程领域，数组中子数组最大累计和是一个经典的算法问题，通常被归类为动态规划或滑动窗口问题。这个问题的目的是找到一个数组中的连续子数组，使得该子数组的元素之和最大，并返回这个最大和。给定的示例中，数组...
找出数组中求和等于y的所有子数组
weixin_30873847的博客
11-07 356
算法记录： 给定一个数组x，每个元素都是正整数，找出其中满足条件“求和等于y”的所有子数组。（简化问题，每个元素都不相等） x=[x1,...,xn]，暴力搜索，复杂度O(2^n)，不可取。 动态规划思路。构建矩阵A： A[j,i]=k，如果k!=-1，表示数组[x1,...,xk]包含求和等于j的子数组，如果k=-1，表示数组[x1,...,xi]不包含求和等于k的子数组。 最终需要返回能构成...
【每周一算】给出一个排好序的数组和一个数，求数组中连续元素的和等于所给数的子数组
JandMin的博客
06-06 1211
给出一个数组，如:[1,2,2,3,5,6,7,8,9],再给一个数5，求数组中连续元素的和等于5个子数组：[1,2,2]和[2,3] 解题： 1、从第一个数开始往后加，直到 == 给定的数，符合要求，返回结果；如果 > 给定的数，结束，不返回结果 2、再从第二个数开始加 .... 代码如下： package com.jandmin.demo.leetcode; import j...
寻找数组中和为指定数字的子数组，可以重复，Leetcode 39
wxwxy
05-18 2148
// 题目：给一个没有重复元素的数组和一个target，输出所有和为target的元素组合，可以重复 // 解法：使用递归，当等于target时就将元素的组合存到List> result中 public class Main { public static void main(String[] args){ List> result = findNum(new int[]{1,3,5,6}
求数组中和为给定值的所有子序列
知行流浪
09-20 6317
package com.zxt.algorithm; import java.util.ArrayList; import java.util.Arrays; /** * 求数组中和为给定值的所有子序列 * * 如：数组[1,2,3,4,5,6]，sum=7时，满足条件的子数组有[1,2,4],[3,4],[2,5],[1,6]; * * @author zxt * */ p
根据数组数据，得到和一定的所有子集
u010633678的专栏
05-03 343
给定一个数字数组，设定一个目标值， 然后以这个数组为数据源，要求给出所有的子集，这些子集中数据的和要等于设定的目标值。例如： 数字数组： [1,2,3,4,5,6] 目标值为 7 那么，所有和为7的子集有[1,2,4] [3,4]...... [code="java"]import java.util.Stack; /** * 给定一个数字数组，设定一个目标值， 然后以这个数组为数...
易语言子程序返回多维数组的实现方法
07-24
本篇文章将深入探讨易语言中子程序如何返回多维数组，以及如何处理列表框数组。 首先，我们要理解易语言中的数组概念。数组是一种数据结构，它允许存储一组具有相同类型的元素。在易语言中，数组可以是一维的，也...
提取json中子节点的数据保存到数组
02-18
提取json中子节点的数据保存到数组
能否连接形成数组1
08-03
这个问题是关于数组操作的，具体是一个名为 "canFormArray" 的编程挑战，源自 LeetCode 网站。挑战的目标是判断是否能通过给定的数组 `pieces` 中的子数组，按照原有的顺序连接起来得到目标数组 `arr`，并且过程中不...
中子寿命难题和中子镜中子振荡
03-31
标准模型以其当前的精度预测中子$$ \β$$β-衰变时间$$ \ tau _ \ mathrm {SM} = 878.7 \ pm 0.6 $$τSM= 878.7±0.6 s，与 在阱实验中测量的中子寿命$$ \ tau_ \ mathrm {trap} = 879.4 \ pm 0.6 $$τtrap= 879.4±...
查找数组中和为某个值的元素对的个数
09-05
查找数组中和为某个值的元素对的个数。 2--sum。 http://blog.csdn.net/qq575787460/article/details/39085999的资源
和为定值的子数组
qq_43727272的博客
12-23 687
暴力法解决和为定值的子数组
求正数数组的子数组之和等于给定值
林云zju的专栏
08-04 5978
问题： 1. 给定一个数组其每个元素都是正数，和一个给定值M，求所有连续的子数组其和等于M。 2. 给定一个正数N，求所有和为N的连续正数序列。 这类求子数组之和的问题与编程之美2.12——快速寻找满足条件的两个数或三个数问题的求解思路相似，都是可用双指针法在O(n)的时间内解决。 1.解法： 我们让两个指针i,j都从数组的第一个元素开始，记变量sum初始化为第一个元素的值，
数组-（Zero Sum Subarray）返回数组中和为某个数的子串数组
千寻的博客
03-01 255
''' Given an integer array, find a subarray where the sum of numbers is zero. Your code should return the index of the first number and the index of the last number. Example Given [-3, 1, 2, -3, 4],...
数组按照固定大小进行拆分
a510750的专栏
08-08 1717
package com.udpdemo.test2;   import java.util.ArrayList; import java.util.List;   /**  *   * @author cuiran  * @version 1.0.0  */ public class ArraySplit {       /**      * @param args      *       *...
8 LeetCode数组中和为定值的子集
weixin_41563161的博客
04-12 4157
数组中和为定值的子集 题目具体是这样的，给定n个数字，比如{2,6,1,7,4,9}，并给定一个SUM，比如SUM=20，在上述这6个数字中，挑出一些，使得他们的和等于SUM，把所有的组合都找出来。我们这个例子的结果就是： 1 + 2 + 4 + 6 + 7 = 20 1 + 4 + 6 + 9 = 20 4 + 7 + 9 = 20 ...
给定整数数组，输出所有和为给定整数值的子集
weixin_34335458的博客
11-02 374
2019独角兽企业重金招聘Python工程师标准>>> ...
如何改变数组中子数组的子数组的对象中的值 js语法
最新发布
06-01
如果您需要改变数组中子数组的子数组中的对象的值，您可以使用嵌套的循环来完成这个任务。以下是一个示例代码： ```javascript const arr = [ [{name: 'Alice', age: 20}, {name: 'Bob', age: 30}], [{name: '...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值