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 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:

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

Response:

{
  "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), then call execute with:

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

HTTP (no key)

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.

CLI

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/.

Related tools

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