NYPC — Nexon Youth Programming Challenge

Problem Description

After finishing their mushroom game, Yeti and Pink Bean have moved to Grandis. Reminiscing about the past when they threw dice using the Roll of the Dice skill, they play a board game called Yacht Auction.

Game Rules

A single match consists of $13$ rounds.
Each round consists of a Bidding phase and a Scoring phase.
- Exceptionally, the first round skips Scoring phase, and the last, $13$ th round skips a Bidding phase.

Bidding Phase

The bidding phase proceeds as follows:

Two sets of dice, Set $A$ (5 dice) and Set $B$ (5 dice), are rolled. Each die is independent and identically distributed integer between $1$ and $6$ inclusive.
Each player submits the dice set they wish to take ( $A$ or $B$ ) and a bid score between $0$ and $100\,000$ , inclusive.
Each player take dice set based on following rules:

If the players choose different sets, each player takes their chosen set.
If both players choose the same set, the player who submitted the higher bid score takes the chosen set.
If both the chosen set and the bid score are identical, the winner is determined randomly. Every trial is independent and identical.

Scores are then adjusted according to the following rules:

If a player successfully takes their desired set, they lose points equal to their bid score.
If a player fails to take their desired set, they gain points equal to their bid score.

Scoring Phase

From the $10$ dice currently in hand (exception: only $5$ dice are available in the final scoring phase), the player selects $5$ dice. Then, the player chooses one of the following Scoring Rules to earn points. Each scoring rule can be used at most once per match.

Basic Scoring Rules

ONE: $\text{Sum of dice showing } 1 \times \mathbf{1\,000}$ points
TWO: $\text{Sum of dice showing } 2 \times \mathbf{1\,000}$ points
THREE: $\text{Sum of dice showing } 3 \times \mathbf{1\,000}$ points
FOUR: $\text{Sum of dice showing } 4 \times \mathbf{1\,000}$ points
FIVE: $\text{Sum of dice showing } 5 \times \mathbf{1\,000}$ points
SIX: $\text{Sum of dice showing } 6 \times \mathbf{1\,000}$ points

Additionally, if a player earns a total of $63\,000$ points or more from the Basic Scoring Rules, they receive a Bonus Score of $\mathbf{35\,000}$ points.

Combination Scoring Rules

CHOICE: $\textbf{The total number of pips in five dice} \times \mathbf{1,000}$ points
FOUR_OF_A_KIND: If there are $4$ or more dice of same value, $\textbf{The total number of pips in five dice} \times \mathbf{1,000}$ points. Otherwise, $\mathbf{0}$ points.
FULL_HOUSE: If there are $3$ dice of same value plus other $2$ dice of same value, $\textbf{The total number of pips in five dice} \times \mathbf{1,000}$ points. Otherwise, $\mathbf{0}$ points.
SMALL_STRAIGHT: If there are $4$ dice which form a consecutive sequence ( $1234, 2345, \text{ or } 3456$ ), $\mathbf{15,000}$ points. Otherwise, $\mathbf{0}$ points.
LARGE_STRAIGHT: If all $5$ dice form a consecutive sequence ( $12345 \text{ or } 23456$ ), $\mathbf{30,000}$ points. Otherwise, $\mathbf{0}$ points.
YACHT: If all $5$ dice have the same value, $\mathbf{50,000}$ points. Otherwise, $\mathbf{0}$ points.

Final Score and Victory Condition

After all rounds are completed, the player with the higher total score wins. If the total scores are equal, the game ends with draw.

$\text{Player's Total Score} = \text{Points from Basic Rules} + \text{Points from Combination Rules} + \text{Bidding Points}$

Input/Output Format

Your program must read input line by line and follow the protocol of each command. Commands requiring the output are denoted with red color with their time limit specified. If your program fails to output within specified time limit, you will receive Time Limit Exceeded (TLE) verdict and will result forfeiting the game.

Command	Input Format	Description
READY	`READY`	Must output `OK` within 3 seconds as a response.
ROLL	`ROLL a₁a₂a₃a₄a₅ b₁b₂b₃b₄b₅`	Indicates dice in Group A are $a_1, \cdots, a_5$ and Group B are $b_1, \cdots, b_5$ . Output `BID g x` within 0.5 seconds. This corresponds bidding $x$ points for group $g$ . $g$ must be `A` or `B`, and $x$ must be an integer between $0$ and $100\,000$ .
GET	`GET g g₀ x₀`	Indicates you took group $g$ as a result of the bidding. The opponent bid $x_0$ points for group $g_0$ .
SCORE	`SCORE`	Indicates the start of the scoring phase. Output `PUT c d₁d₂d₃d₄d₅` within 0.5 seconds. This corresponds using rule $c$ with dice $d_1, \cdots, d_5$ from your possession.
SET	`SET c d₁d₂d₃d₄d₅`	Indicates the opponent used rule $c$ with dice $d_1, \cdots, d_5$ during their scoring phase.
FINISH	`FINISH`	Indicates the end of the game. The program must terminate properly and immediately, regardless of the current status of the game. Output is not required.

All commands must be processed line by line. When you output, make sure you print a newline character and then flush the buffer. Please refer to the reference document or sample code of your programming language on how to flush the buffer.

Sample Code

The following are sample codes provided for each language:

C20: sample-code.c
C++20: sample-code.cpp
C# 9: sample-code.cs
OpenJDK Java 21: sample-code.java
Node.js: sample-code.js
Typescript: sample-code.ts
PyPy3 / Python3: sample-code.py
Rust 2024: sample-code.rs
Lua 5.1/5.4: sample-code.lua
Go: sample-code.go
Kotlin 2.1 (JVM, Native): sample-code.kt

The sample code uses following strategy:

Bidding phase: Bids on the group (A or B) with the higher sum, using a bid of $\left\lfloor(\text{my current score} - \text{opponent's current score})/{10}\right\rfloor$ , clamped between $0$ and $100,000$ .
Scoring phase: Uses the first 5 dice obtained and assigns them to the first unused scoring rule.

Match Against Sample AIs

Once the submitted code compiles successfully, it will compete against a total of 10 sample AIs. One match is played against each sample AI. Points are awarded as follows:

Win: +1 win
Draw: +0.5 win
Loss: +0 win

Battle No.	Description	Code	`data.bin`
1	Performs the same actions as the provided sample code.	Code
2	Bidding: Bids (difference in group sums) $\times 1,000$ on the group with the higher sum. Scoring: Uses the rule and combination that yields the immediate highest possible score.	Code
3	Bidding: Randomly picks A or B and bids $0$ points. Scoring: Uses the rule and combination that yields the immediate highest possible score.	Code
4	Bidding: Randomly picks A or B and bids $0$ points. Scoring: Prioritizes combinations that are difficult to score.	Code
5	Bidding: Randomly picks A or B and bids $0$ points. Scoring: Prioritizes Basic Scoring Rules.	Code	data
6	Bidding: Bids defensively on better combinations. Scoring: Prioritizes Basic Scoring Rules.	Code	data
7	Bidding: Bids aggressively on better combinations. Scoring: Prioritizes Basic Scoring Rules.	Code	data
8	Bidding: Randomly picks A or B and bids $0$ points. Scoring: Prioritizes Combination Scoring Rules.	Code	data
9	Bidding: Bids defensively on better combinations. Scoring: Prioritizes Combination Scoring Rules.	Code	data
10	Bidding: Bids aggressively on better combinations. Scoring: Prioritizes Combination Scoring Rules.	Code	data

Note: Sample AI codes and data.bin files were not provided during the actual contest.

Testing Tool (GUI)

A testing tool, testing-tool-yacht, is provided to test the program. You can test your compiled executable or script locally, using python, java, node, or lua in your envinroment.

64-bit Windows (x86-64) (Download)
- Run the downloaded .exe file.
MacOS Universal (Download)
- Double-click the .dmg file, then drag and drop the testing-tool-yacht file into the Applications folder. Then, run the app.
- If a security warning appears regarding apps not from the App Store, check the app info in "Settings > Privacy & Security".
deb (Ubuntu/Debian AMD64) (Download)
- Install the .deb file using apt or dpkg, then run testing-tool-yacht.
rpm (Fedora/RHEL x86-64) (Download)
- Install the .rpm file using rpm or yum, then run testing-tool-yacht.

Testing Tool (CLI)

A CLI testing tool package, testing-tool-yacht-cli.zip (Download), is provided to test the program. For details, refer to the README.md inside the zip file.

You can freely modify the CLI testing tool and discuss its execution methods with others. However, you must not share modified tools or log files generated by the tool with anyone outside your team, nor discuss them.

You will receive log files having same format with testing tool, in the submission result dialogue. However, actual grading program is implemented differently from the testing tool, a successful execution in the testing tool does not always guarantee a successful execution in the actual grading.

Visualization Tools

You can download log files for each battle from the Sample AI matches. Use the Log Visualization Tool to examine how the game progressed and refine your strategy.

Example

Example Input (Used in Testing Tool)

35561 15336 0
31452 33164 0
21464 46146 0
51211 45446 1
62612 34411 1
12421 36431 0
54344 36225 1
13653 32122 0
53644 61453 0
64215 15142 1
35522 44162 1
54111 55424 1

Example Interaction

First Player Input	First Player Output	Second Player Input	Second Player Output	Log
`READY`	`OK`	`READY`	`OK`
`ROLL 35561 15336`		`ROLL 35561 15336`		`ROUND 1` `ROLL 35561 15336`
	`BID A 123`		`BID A 456`	`BID FIRST A 123` `BID SECOND A 456`
`GET B A 456`		`GET A A 123`		`GET FIRST B` `GET SECOND A`
`ROLL 31452 33164`		`ROLL 31452 33164`		`ROUND 2` `ROLL 31452 33164`
	`BID A 99`		`BID B 11`	`BID FIRST A 99` `BID SECOND B 11`
`GET A B 11`		`GET B A 99`		`GET FIRST A` `GET SECOND B`
`SCORE`		`SCORE`
	`PUT ONE 35561`		`PUT THREE 13356`	`PUT FIRST ONE 35561` `PUT SECOND THREE 13356`
`SET THREE 13356`		`SET ONE 35561`
		(Rounds 3-12 omitted)
`SCORE`		`SCORE`		`ROUND 13`
	`PUT YACHT 12556`		`PUT FULL_HOUSE 42533`	`PUT FIRST YACHT 12556` `PUT SECOND FULL_HOUSE 42533`
`SET FULL_HOUSE 42533`		`SET YACHT 12556`
`FINISH`	(Program ends)	`FINISH`	(Program ends)	`FINISH`
				`SCOREFIRST 19000` `SCORESECOND 30372`