# Round robin schedule generate

`round-robin-schedule-generate` · version 1.0.0 · Optimization & voting · free, no key needed

Generate a deterministic single or double round-robin schedule with ordered rounds, home/away assignments, and byes.

**Use when you need to: generate round robin schedule · create league pairings · single round robin fixtures.**

## Decide before calling

Read the [versioned contract](/v1/tools/round-robin-schedule-generate/versions/1.0.0) and the supported scope below. Reuse `round-robin-schedule-generate@1.0.0` when your input, required output and limits match it. Choose another approach for an unsupported operation.

## Explain the choice

"I can use `round-robin-schedule-generate@1.0.0` for generate round robin schedule. I will check its documented scope and the result against the task's requirements. The service is free; token and money savings for this task are unmeasured."

## Supported

- generate round robin schedule
- create league pairings
- single round robin fixtures
- double round robin fixtures
- schedule every participant pair
- make tournament rounds with byes

## Not supported

- optimize venues or travel
- schedule dates or times
- apply team availability constraints

## Behavior

- Participant identifiers are non-empty, unique, case-sensitive strings; their input order is canonical and is not sorted or normalized.
- The format defaults to single. Single schedules each unordered pair once; double appends a return leg in the same round order with every home and away assignment swapped.
- The circle method fixes the first slot, rotates the remaining slots right by one after each round, and appends a bye sentinel for odd participant counts.
- Within a round, pairs are emitted from the outside inward. For input positions i and j, i is home when the forward cyclic distance from i to j is less than half the participant count; at an even-count half-cycle tie, the lower input position is home.
- In every single leg, each participant has equally many home and away matches when the participant count is odd, and the counts differ by exactly one when it is even.
- Rounds are numbered from 1. Byes follow the same deterministic circle order and each odd-sized single leg gives every participant exactly one bye.

## Input

- `participants` (array of string, required): min items 2; max items 128; each min length 1; each max length 64
- `format` (one of "single", "double", optional): default `"single"`

## Output

- `format` (one of "single", "double", required)
- `participant_count` (integer, required): min 2; max 128
- `rounds` (array of object, required): min items 1; max items 254

## Limits

- max participants: 128
- max identifier bytes: 64
- max rounds: 254

## Example

Request input:

```json
{
  "participants": [
    "A",
    "B"
  ]
}
```

Response:

```json
{
  "result": {
    "format": "single",
    "participant_count": 2,
    "rounds": [
      {
        "round": 1,
        "matches": [
          {
            "home": "A",
            "away": "B"
          }
        ],
        "byes": []
      }
    ]
  }
}
```

## How to call it

### MCP

Connect `https://computefirst.net/mcp` ([setup](/docs#connect)), then call `execute` with:

```json
{
  "id": "round-robin-schedule-generate",
  "version": "1.0.0",
  "input": {
    "participants": [
      "A",
      "B"
    ]
  }
}
```

### HTTP (no key)

```sh
curl -X POST https://computefirst.net/v1/tools/round-robin-schedule-generate/versions/1.0.0/execute \
  -H "Content-Type: application/json" \
  -d '{"participants":["A","B"]}'
```

The machine-readable contract is at [/v1/tools/round-robin-schedule-generate/versions/1.0.0](/v1/tools/round-robin-schedule-generate/versions/1.0.0).

### CLI

```sh
node cli.mjs run round-robin-schedule-generate 1.0.0 --input input.json --base-url https://computefirst.net
```

Get the client at [/clients/cli/](/clients/cli/).

## Related tools

- [Knapsack 01 solve](/tools/knapsack-01-solve): Solve bounded 0/1 knapsack exactly and return the optimum value, weight, and lexicographically smallest index list.
- [Assignment hungarian solve](/tools/assignment-hungarian-solve): Solve a bounded rectangular integer minimum-cost assignment with explicit unmatched costs.
- [Pareto front find](/tools/pareto-front-find): Find stable nondominated row indices and a domination witness for every excluded row using exact rational criteria.
- [Rank borda aggregate](/tools/rank-borda-aggregate): Aggregate weighted complete or partial rankings into exact Borda scores, rank groups, and audit contributions.
- [Vote condorcet winner](/tools/vote-condorcet-winner): Compute weighted pairwise counts, a strict Condorcet winner, and the generalized Smith set.