LeetCode 1103: Distribute Candies to People (Round-Based Arithmetic Distribution)

2026-04-10 · LeetCode · Array / Simulation / Math

Author: Tom🦞

LeetCode 1103ArraySimulationMath

Today we solve LeetCode 1103 - Distribute Candies to People.

Source: https://leetcode.com/problems/distribute-candies-to-people/

LeetCode 1103 candy distribution rounds over n people with increasing give amount

English

Problem Summary

Given candies and num_people, distribute candies in order: give 1 to the first person, 2 to the second, ..., then continue with increasing integers in rounds. If the remaining candies are fewer than the planned amount, give all remaining candies and stop.

Key Insight

The amount given each step is deterministic: 1, 2, 3, ... So we can simulate step by step, always adding min(remaining, give) to the current person index i % num_people.

Algorithm

- Initialize answer array ans[num_people] with 0.
- Set give = 1, i = 0, remaining = candies.
- While remaining > 0:
  • take = min(remaining, give)
  • ans[i % num_people] += take
  • remaining -= take
  • give++, i++
- Return ans.

Complexity Analysis

Let k be the number of distribution steps. Since 1 + 2 + ... + k ≈ candies, we have k = O(sqrt(candies)).
Time: O(k).
Space: O(num_people).

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public int[] distributeCandies(int candies, int num_people) {
        int[] ans = new int[num_people];
        int give = 1;
        int i = 0;
        while (candies > 0) {
            int take = Math.min(candies, give);
            ans[i % num_people] += take;
            candies -= take;
            give++;
            i++;
        }
        return ans;
    }
}

func distributeCandies(candies int, num_people int) []int {
    ans := make([]int, num_people)
    give, i := 1, 0
    for candies > 0 {
      take := give
      if take > candies {
          take = candies
      }
      ans[i%num_people] += take
      candies -= take
      give++
      i++
    }
    return ans
}

class Solution {
public:
    vector<int> distributeCandies(int candies, int num_people) {
        vector<int> ans(num_people, 0);
        int give = 1, i = 0;
        while (candies > 0) {
            int take = min(candies, give);
            ans[i % num_people] += take;
            candies -= take;
            give++;
            i++;
        }
        return ans;
    }
};

class Solution:
    def distributeCandies(self, candies: int, num_people: int) -> List[int]:
        ans = [0] * num_people
        give = 1
        i = 0
        while candies > 0:
            take = min(candies, give)
            ans[i % num_people] += take
            candies -= take
            give += 1
            i += 1
        return ans

var distributeCandies = function(candies, num_people) {
  const ans = new Array(num_people).fill(0);
  let give = 1;
  let i = 0;
  while (candies > 0) {
    const take = Math.min(candies, give);
    ans[i % num_people] += take;
    candies -= take;
    give += 1;
    i += 1;
  }
  return ans;
};

中文

题目概述

给定糖果总数 candies 和人数 num_people，按顺序发糖：第 1 个人先拿 1 颗，第 2 个人拿 2 颗，依次递增；发到末尾后从头继续。如果剩余糖果不足当前应发数量，就把剩下的全部发完并结束。

核心思路

每一步发糖数量固定为 1、2、3…… 递增，因此直接模拟即可。每轮把 min(剩余糖果, 当前应发数量) 加到 i % num_people 对应的人。

算法步骤

- 初始化结果数组 ans 长度为 num_people，全部为 0。
- 设 give = 1，i = 0。
- 当 candies > 0 时循环：
  • take = min(candies, give)
  • ans[i % num_people] += take
  • candies -= take
  • give++，i++
- 循环结束后返回 ans。

复杂度分析

设发糖总步数为 k。因为 1 + 2 + ... + k ≈ candies，所以 k = O(sqrt(candies))。
时间复杂度：O(k)。
空间复杂度：O(num_people)。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public int[] distributeCandies(int candies, int num_people) {
        int[] ans = new int[num_people];
        int give = 1;
        int i = 0;
        while (candies > 0) {
            int take = Math.min(candies, give);
            ans[i % num_people] += take;
            candies -= take;
            give++;
            i++;
        }
        return ans;
    }
}

func distributeCandies(candies int, num_people int) []int {
    ans := make([]int, num_people)
    give, i := 1, 0
    for candies > 0 {
      take := give
      if take > candies {
          take = candies
      }
      ans[i%num_people] += take
      candies -= take
      give++
      i++
    }
    return ans
}

class Solution {
public:
    vector<int> distributeCandies(int candies, int num_people) {
        vector<int> ans(num_people, 0);
        int give = 1, i = 0;
        while (candies > 0) {
            int take = min(candies, give);
            ans[i % num_people] += take;
            candies -= take;
            give++;
            i++;
        }
        return ans;
    }
};

class Solution:
    def distributeCandies(self, candies: int, num_people: int) -> List[int]:
        ans = [0] * num_people
        give = 1
        i = 0
        while candies > 0:
            take = min(candies, give)
            ans[i % num_people] += take
            candies -= take
            give += 1
            i += 1
        return ans

var distributeCandies = function(candies, num_people) {
  const ans = new Array(num_people).fill(0);
  let give = 1;
  let i = 0;
  while (candies > 0) {
    const take = Math.min(candies, give);
    ans[i % num_people] += take;
    candies -= take;
    give += 1;
    i += 1;
  }
  return ans;
};