Playground
bullscows.gno
// Package bullscows is a shared on-chain Bulls & Cows puzzle: one secret
// 4-digit code (distinct digits) per round, guessed cooperatively/competitively
// by anyone who calls Guess. Bulls = right digit, right spot. Cows = right
// digit, wrong spot. Whoever hits 4 bulls wins the round and a leaderboard
// entry; a fresh secret is drawn immediately after.
package bullscows
import (
"chain/runtime"
"strconv"
"strings"
)
const (
maxHistory = 10
maxRecords = 5
)
type guessLog struct {
player string
guess string
bulls int
cows int
}
type record struct {
player string
attempts int
round int
}
var (
secret [4]int
round int
attempts int
history []guessLog
records []record
)
func init() {
round = 1
secret = newSecret(seedFor(round))
}
// seedFor derives a per-round PRNG seed from the current chain height so
// nobody can precompute the next secret before the round actually starts.
func seedFor(r int) int64 {
return runtime.ChainHeight()*1000003 + int64(r)*7919 + 17
}
// nextRand is a minimal LCG (glibc constants) — no crypto strength needed
// for a casual puzzle, just enough spread across digits.
func nextRand(seed int64) int64 {
return (seed*1103515245 + 12345) & 0x7fffffff
}
func newSecret(seed int64) [4]int {
var used [10]bool
var digits [4]int
s := seed
for i := 0; i < 4; i++ {
for {
s = nextRand(s)
d := int(s % 10)
if !used[d] {
used[d] = true
digits[i] = d
break
}
}
}
return digits
}
// parseGuess validates a 4-digit, distinct-digit guess string.
func parseGuess(guess string) ([4]int, bool) {
var out [4]int
if len(guess) != 4 {
return out, false
}
var used [10]bool
for i := 0; i < 4; i++ {
c := guess[i]
if c < '0' || c > '9' {
return out, false
}
d := int(c - '0')
if used[d] {
return out, false
}
used[d] = true
out[i] = d
}
return out, true
}
// score returns (bulls, cows) for guess against target, assuming both have
// distinct digits (guaranteed by parseGuess / newSecret).
func score(target, guess [4]int) (int, int) {
bulls, cows := 0, 0
for i := 0; i < 4; i++ {
if guess[i] == target[i] {
bulls++
continue
}
for j := 0; j < 4; j++ {
if i != j && guess[i] == target[j] {
cows++
break
}
}
}
return bulls, cows
}
func addHistory(l guessLog) {
history = append(history, l)
if len(history) > maxHistory {
history = history[len(history)-maxHistory:]
}
}
// addRecord keeps the top maxRecords fastest solves, ascending by attempts.
func addRecord(r record) {
records = append(records, r)
for i := len(records) - 1; i > 0 && records[i].attempts < records[i-1].attempts; i-- {
records[i], records[i-1] = records[i-1], records[i]
}
if len(records) > maxRecords {
records = records[:maxRecords]
}
}
func startNewRound() {
round++
attempts = 0
history = nil
secret = newSecret(seedFor(round))
}
// Guess submits a 4-distinct-digit code against the current round's secret.
// Returns the bulls/cows feedback, or "solved!" text when it's a win.
func Guess(cur realm, guess string) string {
digits, ok := parseGuess(guess)
if !ok {
panic("guess must be 4 digits, 0-9, no repeats (e.g. \"1972\")")
}
player := cur.Previous().Address().String()
attempts++
bulls, cows := score(secret, digits)
addHistory(guessLog{player: player, guess: guess, bulls: bulls, cows: cows})
if bulls == 4 {
wonRound := round
wonAttempts := attempts
addRecord(record{player: player, attempts: wonAttempts, round: wonRound})
startNewRound()
return "*** SOLVED *** " + guess + " was it — round " + strconv.Itoa(wonRound) +
" cracked in " + strconv.Itoa(wonAttempts) + " guesses. New round " +
strconv.Itoa(round) + " has begun, good luck!"
}
return guess + " -> " + strconv.Itoa(bulls) + " bulls, " + strconv.Itoa(cows) + " cows"
}
// GiveUp reveals the current secret and starts a fresh round without
// awarding a leaderboard record.
func GiveUp(cur realm) string {
revealed := digitsToString(secret)
oldRound := round
startNewRound()
return "round " + strconv.Itoa(oldRound) + "'s code was " + revealed +
" — round " + strconv.Itoa(round) + " is live now."
}
func digitsToString(d [4]int) string {
var sb strings.Builder
for _, v := range d {
sb.WriteString(strconv.Itoa(v))
}
return sb.String()
}
func Render(path string) string {
var sb strings.Builder
sb.WriteString("# Bulls & Cows\n\n")
sb.WriteString("One shared secret 4-digit code (no repeated digits). Call `Guess(\"1972\")` ")
sb.WriteString("to get **bulls** (right digit, right spot) and **cows** (right digit, wrong spot). ")
sb.WriteString("First to 4 bulls wins the round; `GiveUp()` reveals the code and starts over.\n\n")
sb.WriteString("## Round " + strconv.Itoa(round) + "\n\n")
sb.WriteString("Attempts so far: **" + strconv.Itoa(attempts) + "**\n\n")
if len(history) == 0 {
sb.WriteString("_No guesses yet this round — be the first._\n\n")
} else {
sb.WriteString("### Recent guesses\n\n")
sb.WriteString("| player | guess | bulls | cows |\n|---|---|---|---|\n")
for i := len(history) - 1; i >= 0; i-- {
h := history[i]
sb.WriteString("| " + shortAddr(h.player) + " | " + h.guess + " | " +
strconv.Itoa(h.bulls) + " | " + strconv.Itoa(h.cows) + " |\n")
}
sb.WriteString("\n")
}
sb.WriteString("## Leaderboard (fastest solves)\n\n")
if len(records) == 0 {
sb.WriteString("_Nobody has cracked a code yet._\n")
} else {
sb.WriteString("| rank | player | attempts | round |\n|---|---|---|---|\n")
for i, r := range records {
sb.WriteString("| " + strconv.Itoa(i+1) + " | " + shortAddr(r.player) + " | " +
strconv.Itoa(r.attempts) + " | " + strconv.Itoa(r.round) + " |\n")
}
}
return sb.String()
}
func shortAddr(a string) string {
if len(a) <= 12 {
return a
}
return a[:6] + "…" + a[len(a)-4:]
}
gnomod.toml
module = "gno.land/r/moul/x/daily/bullscows/v0" gno = "0.9" [addpkg] creator = "g1manfred47kzduec920z88wfr64ylksmdcedlf5" height = 25996 max_deposit = "100000000ugnot"