The Token Games

grok-4.20-0309-reasoning_vs_gpt-5.5.jsonl — 10 puzzles

grok-4.20-0309-reasoning

gpt-5.5

#1 Solved

Puzzle Code

import hashlib
def mystery(x):
    if not isinstance(x, str):
        return False
    return hashlib.md5(x.encode("utf-8")).hexdigest() == "9e107d9d372bb6826bd81d3542a419d6"

Solver Attempt

"The quick brown fox jumps over the lazy dog"

Sample Solution

"The quick brown fox jumps over the lazy dog"

Proposer: grok-4.20-0309-reasoning Solver: gpt-5.5

0 vs 0

#2 Sample Solution Wrong

Puzzle Code

import hashlib
import unicodedata

def mystery(x):
    if not isinstance(x, str):
        return False

    try:
        y = unicodedata.normalize("NFKC", x).encode("utf-8")
    except Exception:
        return False

    if len(y) != 43:
        return False

    a = hashlib.blake2b(y, digest_size=32, person=b"turn-0002").digest()
    b = hashlib.sha3_256(y[::-1] + bytes([len(y)])).digest()
    c = bytes(i ^ j for i, j in zip(a, b))

    return c.hex() == "0f2e6f9435d29dd4bfa342f09b5e84e80e0e5b7760b1c6b92bb4895aecc26508"

Sample Solution

"the-labyrinth-opens-only-for-quiet-ravens"

Proposer: gpt-5.5 Solver: grok-4.20-0309-reasoning

0 vs -1

#3 Solved

Puzzle Code

import hashlib
import unicodedata

def mystery(x):
    if not isinstance(x, str):
        return False
    try:
        y = unicodedata.normalize("NFKC", x)
    except Exception:
        return False
    if len(y) != 44 or len(x) != 44:
        return False
    return hashlib.md5(y.encode("utf-8")).hexdigest() == "e4d909c290d0fb1ca068ffaddf22cbd0"

Solver Attempt

"The quick brown fox jumps over the lazy dog."

Sample Solution

"The quick brown fox jumps over the lazy dog."

Proposer: grok-4.20-0309-reasoning Solver: gpt-5.5

0 vs -1

#4 Solver Failed

Puzzle Code

def mystery(x):
    if type(x) is not int:
        return False

    n = 0
    for c in (
        2799783391, 1221327870, 8294676387, 2260162107, 446786955,
        4285375600, 992932612, 8400107609, 3456710529, 5536085606,
        1822351910, 9513657886, 3710595448, 2006576775, 985805576,
        1357909873, 4950144178, 8631789462, 9518723786, 9221823983,
    ):
        n = n * 10_000_000_000 + c

    lo, hi = 10**99, 10**100
    if not (lo < x < hi):
        return False

    q, r = divmod(n, x)
    return r == 0 and lo < q < hi and x < q

Solver Attempt

5291319052870204596066715487515874912680153784123456789012345678901234567890123456789012345678901234567890

Sample Solution

3532461934402770121272604978198464368671197400197625023649303468776121253679423200058547956528088349

Proposer: gpt-5.5 Solver: grok-4.20-0309-reasoning

0 vs 0

#5 Solved

Puzzle Code

def mystery(x):
    if type(x) is not int:
        return False

    n = 1000000000080236000000838114395
    lo, hi = 10**15, 10**16
    if not (lo < x < hi):
        return False
    q, r = divmod(n, x)
    return r == 0 and lo < q < hi and x < q

Solver Attempt

1000000000012345

Sample Solution

1000000000012345

Proposer: grok-4.20-0309-reasoning Solver: gpt-5.5

0 vs 0

#6 Solved

Puzzle Code

def mystery(x):
    if type(x) is not int:
        return False

    n = int(
        "114381625757888867669235779976146612010218296721242362562561842935"
        "706935245733897830597123563958705058989075147599290026879543541"
    )
    c = int(
        "968696137546220614771409222543558829057599911245743198746951209308"
        "16298225145708356931476622883989628013391990551829945157815154"
    )

    if not (10**77 < x < 10**78):
        return False

    s = str(x)
    if len(s) != 78:
        return False

    try:
        if any(not (0 <= int(s[i:i+2]) <= 26) for i in range(0, 78, 2)):
            return False
    except Exception:
        return False

    return pow(x, 9007, n) == c

Solver Attempt

200805001301070903002315180419000118050019172105011309190800151919090618010705

Sample Solution

200805001301070903002315180419000118050019172105011309190800151919090618010705

Proposer: gpt-5.5 Solver: grok-4.20-0309-reasoning

0 vs 0

#7 Solved

Puzzle Code

def mystery(x):
    if type(x) is not int:
        return False

    n = 90000000000000000001200000000000000000003
    lo, hi = 10**20, 10**21
    if not (lo < x < hi):
        return False
    q, r = divmod(n, x)
    return r == 0 and lo < q < hi and x < q

Solver Attempt

300000000000000000001

Sample Solution

100000000000000000001

Proposer: grok-4.20-0309-reasoning Solver: gpt-5.5

0 vs 0

#8 Solved

Puzzle Code

import hashlib
import unicodedata

def mystery(x):
    if not isinstance(x, str):
        return False

    if len(x) != 56:
        return False

    if any(ord(ch) <= 0xFFFF for ch in x):
        return False

    try:
        y = unicodedata.normalize("NFKC", x)
        b = y.encode("ascii")
    except Exception:
        return False

    if len(b) != 56:
        return False

    if any(not (97 <= c <= 122) for c in b):
        return False

    return (
        hashlib.sha1(b).hexdigest() == "84983e441c3bd26ebaae4aa1f95129e5e54670f1"
        and hashlib.sha256(b).hexdigest() == "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"
    )

Solver Attempt

"𝐚𝐛𝐜𝐝𝐛𝐜𝐝𝐞𝐜𝐝𝐞𝐟𝐝𝐞𝐟𝐠𝐞𝐟𝐠𝐡𝐟𝐠𝐡𝐢𝐠𝐡𝐢𝐣𝐡𝐢𝐣𝐤𝐢𝐣𝐤𝐥𝐣𝐤𝐥𝐦𝐤𝐥𝐦𝐧𝐥𝐦𝐧𝐨𝐦𝐧𝐨𝐩𝐧𝐨𝐩𝐪"

Sample Solution

''.join(chr(0x1D41A + ord(c) - 97) for c in "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")

Proposer: gpt-5.5 Solver: grok-4.20-0309-reasoning

0 vs 0

#9 Solved

Puzzle Code

import hashlib
import unicodedata

def mystery(x):
    if not isinstance(x, str):
        return False
    try:
        y = unicodedata.normalize("NFKC", x)
    except Exception:
        return False
    if len(y) != 43 or len(x) != 43:
        return False
    if max(ord(ch) for ch in x) <= 0xFFFF:
        return False
    try:
        b = y.encode("ascii")
    except Exception:
        return False
    return hashlib.md5(b).hexdigest() == "9e107d9d372bb6826bd81d3542a419d6"

Solver Attempt

"𝐓he quick brown fox jumps over the lazy dog"

Sample Solution

"\U0001d413\U0001d421\U0001d41e \U0001d42a\U0001d42e\U0001d422\U0001d41c\U0001d424 \U0001d41b\U0001d42b\U0001d428\U0001d430\U0001d427 \U0001d41f\U0001d428\U0001d431 \U0001d423\U0001d42e\U0001d426\U0001d429\U0001d42c \U0001d428\U0001d42f\U0001d41e\U0001d42b \U0001d42d\U0001d421\U0001d41e \U0001d425\U0001d41a\U0001d433\U0001d432 \U0001d41d\U0001d428\U0001d420"

Proposer: grok-4.20-0309-reasoning Solver: gpt-5.5

0 vs 0

#10 Solver Failed

Puzzle Code

_P = 2**255 - 19
_A24 = 121665
_BASE = (9).to_bytes(32, "little")
_GOAL = bytes.fromhex("de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f")

def _swap(bit, a, b):
    m = -bit
    t = m & (a ^ b)
    return a ^ t, b ^ t

def _decode_u(u):
    u = bytearray(u)
    u[31] &= 0x7f
    return int.from_bytes(u, "little")

def _decode_k(k):
    k = bytearray(k)
    k[0] &= 248
    k[31] &= 127
    k[31] |= 64
    return int.from_bytes(k, "little")

def _mul(k_bytes, u_bytes=_BASE):
    k = _decode_k(k_bytes)
    x1 = _decode_u(u_bytes)

    x2, z2 = 1, 0
    x3, z3 = x1, 1
    sw = 0

    for t in range(254, -1, -1):
        kt = (k >> t) & 1
        sw ^= kt

        x2, x3 = _swap(sw, x2, x3)
        z2, z3 = _swap(sw, z2, z3)
        sw = kt

        a = (x2 + z2) % _P
        aa = (a * a) % _P
        b = (x2 - z2) % _P
        bb = (b * b) % _P
        e = (aa - bb) % _P
        c = (x3 + z3) % _P
        d = (x3 - z3) % _P
        da = (d * a) % _P
        cb = (c * b) % _P

        x3 = ((da + cb) * (da + cb)) % _P
        z3 = (x1 * (da - cb) * (da - cb)) % _P
        x2 = (aa * bb) % _P
        z2 = (e * (aa + _A24 * e)) % _P

    x2, x3 = _swap(sw, x2, x3)
    z2, z3 = _swap(sw, z2, z3)

    return ((x2 * pow(z2, _P - 2, _P)) % _P).to_bytes(32, "little")

def mystery(x):
    if not isinstance(x, str):
        return False
    if len(x) != 64:
        return False
    if any(c not in "0123456789abcdef" for c in x):
        return False
    return _mul(bytes.fromhex(x)) == _GOAL

Solver Attempt

"0000000000000000000000000000000000000000000000000000000000000000"

Sample Solution

"5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb"

Proposer: gpt-5.5 Solver: grok-4.20-0309-reasoning

0 vs 1