Apparently that was too much to ask, so I made my own.

Try it: latinum.korff.dev
Code: github.com/addelec/latinum

Features

• PWA support: You can “install” it and use it offline

• Web Share support: You can share the editor link directly

• Clipboard fallback on Firefox: Firefox somehow still doesn’t properly support the Web Share API, so there I resort to copying the link to the clipboard

• No ads and no accounts: It’s literally just a text input and a couple of buttons

And that’s it.

I was annoyed that this didn’t exist, so I made it. If you have ideas or find bugs, feel free to open an issue on GitHub.

Problem summary:

We must mark each cell of the 20×20 grid as either inside or outside.

To help us the grid contains some special cells with the following rules:

Arrow cells:

Arrow cells are per definition outside.

Arrow cells can have one or more arrows, these arrow point in cardinal directions.

Arrow cells force the first inside cells in the pointing-directions to be equidistant from the arrow cell, and no closer inside cell can exist in any direction.

Numbered cells:

Numbered cells are per definition inside.

Numbered cells contain a number, this number specifies the total count of inside cells in the 3×3 neighborhood centered around the cell itself (so a maximum of 9 = itself + 8 neighbors).

Global constraints:

Every inside cell must be connected to every other inside cell.

Every outside cell must be connected to the edge of the grid (so it can be “cut away”).

Definitions:

• We define a cell to be inside if this cell is part of the final box

• We define a cell to be outside if this cell is not part of the final box

• We use “the shape“ or “shape” to refer to the 2 dimensional shape to be folded into a box

• We use “arrow distance“ to refer to the distance between an arrow cell and its corresponding closest inside cells

Solving:

You could solve the puzzle using two different methods.

The first being purely visual using excalidraw or writing a custom tool using something like pygame.

The second being solving the puzzle algorithmically, the simplest approach here is trying to convert the constraints of the puzzle into boolean expressions and using a sat-solver like Z3 to satisfy these constraints.

Z3-Powered solver

So how does one convert the different puzzle constraints?

We start by modelling the grid as an array of integers (“g_{x}_{y}”) with the constraint of each int being >= 0 and <= 1.

I used integers rather than booleans because summing a 3×3 neighborhood becomes trivial with integers.

The neighborhood-constraint:

As specified the neighborhood constraint is rather trivial.

# Constraints for the neighbor counts
for (r,c), val in numbers.items(): # Numbers is an array of positions of number-cells
    neighs = []
    for dr in (-1,0,1):
        for dc in (-1,0,1):
            rr, cc = r+dr, c+dc
            if is_in_grid(rr, cc):
                neighs.append(grid[rr][cc])
    s.add(Sum(neighs) == val) # s is the z3 solver

This code just loops through all numbers and sets the constraint that the amount of inside cells in the 3×3 area must equal the number value.

The arrow-constraint:

The arrow constraint was more tricky to implement.

The basic idea is to generate a distance expression in each direction with nested if conditions.

# Arrow constraints
# Helper to get distance expression by building a ray of Ifs
# It walks backwards from the edge to the cell, building an If chain
# the chain reads if the current cell is inside, return distance, else (if chain)
def get_dist_expr(row, col, dx, dy):

    # Build a list of cells along the specified direction
    cells = []
    curr_row, curr_col = row + dx, col + dy
    while is_in_grid(curr_row, curr_col):
        cells.append((curr_row, curr_col))
        curr_row += dx
        curr_col += dy

    # Start with an arbitrary large distance
    if_chain = 999

    # Iterate backwards to build the If chain, otherwise the last element would have priority
    for i in range(len(cells)-1, -1, -1):
        rr, cc = cells[i]
        dist = i + 1
        # If the cell is inside, return distance, else continue the chain
        if_chain = If(grid[rr][cc] == 1, dist, if_chain)
    return if_chain

dir_map = {"NORTH": (-1, 0), "SOUTH": (1, 0), "EAST": (0, 1), "WEST": (0, -1)}

for (r,c), dirs in arrows.items():
    # Define the target distance of the arrow
    target = Int(f"arrow_target_{r}_{c}")

    s.add(target > 0, target < GRID_SIZE)

    for d_name, (dx, dy) in dir_map.items():
        dist_expr = get_dist_expr(r, c, dx, dy)

        # If the arrow points in this direction, distance must equal target
        # Else distance must be greater than target
        if d_name in dirs:
            s.add(dist_expr == target)
        else:
            s.add(dist_expr > target)

The inside-connectivity-constraint:

This is the constraint that took by far the most time to implement, since I didn’t really know how to describe the idea of connectivity in expressions.

The approach ended up being:

1. Selected one cell that is guaranteed to be inside (I simply used the first number cell), we will call it root

2. Create a new distance grid and set the distance of the root cell to 0

3. Now if a cell is connected it must have a neighbor with a distance of its own distance - 1

# Constraint to force all inside cells to be connected
# Select the first number cell as root (since it is an inside cell per definition), so all inside cells must connect to it
root_r, root_c = list(numbers.keys())[0]

# Idea:
# We check connectivity by essentially doing a flood fill with distance values
# Then if a cell is inside it must have a cardinal neighbor with dist = d-1 otherwise there does not exist a path to the root

# Create a new distance grid for connectivity
d_in = [[Int(f"d_in_{r}_{c}") for c in range(COLS)] for r in range(ROWS)]

for r in range(ROWS):
    for c in range(COLS):
        # If outside, dist is -1
        s.add(Implies(grid[r][c] == 0, d_in[r][c] == -1))

        # If the cell is the root cell, set the distance to 0
        if (r,c) == (root_r, root_c):
            s.add(d_in[r][c] == 0)
            continue

        # Since the cell is not the root cell, its distance must be > 0 if inside
        s.add(Implies(grid[r][c] == 1, d_in[r][c] > 0))

        # Get the cardinal neighbors
        neighs = []
        for dr, dc in [(0,1), (0,-1), (1,0), (-1,0)]:
            rr, cc = r+dr, c+dc
            if is_in_grid(rr, cc):
                neighs.append(d_in[rr][cc])

        # Since the cell is inside, there must exist a neighbor with dist = d-1
        s.add(Implies(grid[r][c] == 1, Or([n == d_in[r][c] - 1 for n in neighs])))

The outside-connectivity-constraint:

The approach of outside-connectivity is similar to the process for inside connectivity. The only difference being is we set a cell to have a distance of 0 if it is on the edge of the grid.

# Connected to edge constraint
# Create a new distance grid for outside connectivity
d_out = [[Int(f"d_out_{r}_{c}") for c in range(COLS)] for r in range(ROWS)]

# Idea:
# If a cell is on the outside and on the boundary, dist = 0
# If a cell is outside and not on the boundary, there must exist a neighbor with dist = d-1

for r in range(ROWS):
    for c in range(COLS):
        s.add(Implies(grid[r][c] == 1, d_out[r][c] == -1))
        s.add(Implies(grid[r][c] == 0, d_out[r][c] >= 0))

        is_boundary = (r == 0 or r == ROWS-1 or c == 0 or c == COLS-1)

        if is_boundary:
            s.add(Implies(grid[r][c] == 0, d_out[r][c] == 0))
            continue

        # If outside and not boundary, dist > 0
        s.add(Implies(grid[r][c] == 0, d_out[r][c] > 0))

        neighs = []
        for dr, dc in [(0,1), (0,-1), (1,0), (-1,0)]:
            rr, cc = r+dr, c+dc
            neighs.append(d_out[rr][cc])

        # If the cell is outside, then there must exist a neighbor with dist = d-1
        s.add(Implies(grid[r][c] == 0, Or([n == d_out[r][c] - 1 for n in neighs])))

The finished grid

After running the code there were 72 different solutions.

To produce a single “consensus” I combined these solutions cell-wise:

• If a cell was inside in all solutions → mark it as inside (green)

• If a cell was outside in all solutions → mark it as outside (white)

• Otherwise → mark it as unsure (grey)

This resulted in the following grid:

Folding

I experimented with automatic folding but ended up simply just folding a printed copy by hand.

This was surprisingly straightforward, because of the rather distinct edge geometry making only some folds possible. I marked the unsure cells to remind me that they don’t have to be included.

After a half an hour of fiddling around with scissors and tape, I managed to fold the shape into a box, adding together the numbers on each face and multiplying the sum gave me the following solution: 16414860

Code

Or view to full code here.

This puzzle involved calculating the maximum probability q of a game of baseball played between two robots to reach „full-count“ (three balls and two strikes).

At each turn, the two robots (one as the pitcher and the other as the batter) simultaneously make one of two choices:

• The pitcher can either throw a ball or a strike.

• The batter can either swing or wait.

A running tally of strikes and balls is also maintained.

This process leads to the following matrix:

A game series concludes if any of the following conditions are met:

• The count of balls reaches 4 → Results in the batter gaining 1 point

• The count of strikes reaches 3 → Results in the batter gaining 0 points

• The batter hits a home run → Results in the batter gaining 4 points

The goal of the batter is to maximize its score, while the pitcher aims to minimize it.

Furthermore, the robots use optimal strategies and h has been set to maximize the value of q.

Approach:

1. Find the optimal strategy for the bots

2. Find a function for q that depends on h

3. Find the maximum value of this function

The bots strategy:

Since there is no trivial best strategy I turned to the Nash equilibrium. Essentially it is about the bots removing any possibility of being exploited by another strategy, that means the bots have to be statistically indifferent to every action of their opponent. The bots do this by choosing actions based on probabilities.

So we just need to compute the expected values of each actions combined with the opponents choice and solve them to be equal.

So let b be the probability of the batter swinging and p be the probability of the pitcher throwing a ball.

But how do we get the expected values?

The expected value change with the game state i.e. if the count of strikes has already reached 2 the expected value would obviously be less than if the count of balls has reached 3 instead.

Let’s start by solving the most trivial case 3 balls and 2 strikes. No matter what the bots chose the game must come to an end and the payoffs are known from the puzzle description. So lets construct a payoff-matrix.

$$4 \cdot h \cdot (1-p) = p \;\qquad 1-b = 4 \cdot h \cdot b$$

$$p = \frac{4h}{1+4h} \qquad b = \frac{1}{1+4h}$$

Now we have function for p and b so we could compute the expected value of this game state dependent on h. However doing this for every game state is quite troublesome so this is a task best left to computers.

If we consider the various game states as nodes in a dependency graph, we get the following structure:

# If you are interested in the code, you will find the full code in the github gist

nodes = []

root = Node(0,0)

def build_graph(root):

  # If one extra ball is possible, create that child node
  if root.b != 3:
    child = Node(root.b + 1, root.s)


    if child not in nodes:
      nodes.append(child)
      root.b1 = child
      build_graph(child)
    else:
      root.b1 = nodes[nodes.index(child)]

  # If one extra strike is possible, create that child node
  if root.s != 2:
    child = Node(root.b, root.s + 1)

    if child not in nodes:
      nodes.append(child)
      root.s1 = child
      build_graph(child)
    else:
      root.s1 = nodes[nodes.index(child)]

nodes.append(root)  
build_graph(root)


print(f"Graph nodes: {len(nodes)}")

Finding h and q

Now that we have p and b for every possible game state we have solved the game.

That alone would hardly be an entertaining viewing experience, so we need to find the value for h maximizing q.

I have done this by mapping every path from the 0,0-node to the 3,2-node.

# If you are interested in the code, you will find the full code in the github gist

Now we have a function giving us q for a given h.

Now we just need to find the maximum within the Interval [0,1].

from scipy.optimize import minimize_scalar

res = minimize_scalar(lambda h: -sum_func(h), bounds=(0,1), method='bounded')

print("h =", res.x)                # h = 0.22697434289547633
print("q =", sum_func(res.x))      # q = 0.2959679933709649

And there we have it.

The maximal value for q is: 0.2959679933

Full code:

View Github Gist

This puzzle involved extracting a sentence from a PDF file. The PDF contained images of mosaics arranged in a 3×3 grid, with some Scrabble letters on the sides. (Here’s the link to the PDF: https://www.janestreet.com/static/pdfs/puzzles/june-2025-puzzle.pdf)

Solving:

Starting out, I removed the perspective from these images.

This allowed me to figure out the relative sizes of the squares. Originally, these sizes didn’t seem to suggest anything, but after multiplying them by the factor 45, a pattern began to emerge.

The sizes were now as follows:

• Grey: 9

• Brown: 8

• Yellow: 7

• Light Blue: 6

• Pink-Red: 5

• Dark Blue: 4

• Orange: 3

• Green: 2

It appears that a square with a side length of 1 is missing.

Now the next question: I assumed the original mosaic had to be recreated somehow, so how many of these squares am I allowed to use?

To figure that out I simply counted the squares on the board as well as the table next to it. This resulted in the same distribution as the sizes above.

To verify I multiplied all the sizes squared by their count to figure out if I could actually cover the grid.

The grid is 45×45 so in total it contains 2025 spaces. Calculating the area of all squares yields 2024 spaces. So we are one space short.

I assumed that this 1×1 square would have to be in line with some of the scrabble letters, so I could extract text. But this turned out to be false.

Nevertheless I created a small tool to aid with solving these grids.

An hour or so of trying and failing to solve the board to satisfy the constraints of this assumption. I gave up and just tried to solve the board.

This turned out to be more straightforward than expected, after less than half an hour I managed to solve all of the grids.

So, what’s next?

I had the solved boards but no clue on how to extract a sentence.

This was by far the most difficult part of the puzzle.

I tried to solve the boards differently, but was unsuccessful.

I tried drawing lines between the letters to see if the lines and spaces would intersect.

One out of these desperate attempts actually was successful.

I wrote down the alphabet and placed it next to the board (I was using Excalidraw) with the intention that crossing out the Scrabble letters would leave me with something interesting. That didn’t really happen but I found something else.

I noticed that the Scrabble letters and their spacing were perfectly aligned with the alphabet.

Below is an image showing the finished grids with the repeating alphabet next to the sides (this was created in Excel which would have made this discovery trivial).

Now I just guessed that the letter from the left came first and the one from the top second.

This results in:

SU MO FC
UB ES IS
SQ UA RE

SUMOFCUBESISSQUARE
Solution: SUM OF CUBES IS SQUARE

Tool: https://static.korff.dev/blog/some-ones-somewhere (AI used for translating and some UI tweaks)

This puzzle is about solving an 11 by 11 grid containing 9 different bordered regions.

Source: https://www.janestreet.com/puzzles/may-2025-update.png

Regions:

Start by inserting numbers 1-9 into the different regions. Not all numbers in the set 1-9 need to be used.

1. Each region needs to contain the same digit throughout

2. Neighboring regions must contain different digits

The same number can be reused in non-adjacent regions (Restriction 2)

Tiles:

Next, tiles need to be placed into the grid.

1. Tiles can’t be placed on yellow “locked” spaces

2. Tiles can’t be placed directly above or below another tile

3. Tiles need to be at least 2 spaces apart horizontally

   • This ensures that each segment between tiles forms a valid number (minimum two digits)

   • Tiles can be placed directly next to the grid borders

   • Tiles cannot be placed one space away from the grid borders since this one space cannot form a valid number

When a tile is placed, it displaces the digit it covers. This displaced value is absorbed by its four orthogonal neighbors. A few additional constraints:

• No space can be incremented past 9

• Yellow “locked” spaces cannot be changed => They always retain the original region-digit

• As a result of this distribution-process two spaces in different regions are allowed to have the same digit

After this operation is complete no numbers (formed between tiles) are allowed to repeat within the grid.

Clues:

Clues are written on each row. Each number (consecutive digits between tiles) needs to satisfy the given clue.

Solution:

Once the grid is complete and all clues are satisfied, the solution is the sum of the final numbers in the grid.

Full puzzle: https://www.janestreet.com/puzzles/number-cross-5-index/

Preliminary Analysis

A closer look at the puzzle allows for some early deductions:

• The blue region has to be mapped to the number 2, since the locked spaces in the second row cannot be altered. Thus they must still have their original value and that value must satisfy the clue “product of digits is 20”. The prime factorization of 20 is 2×2×5.

• This also helps to fix the tile positions in row 09: ◻️◻️⬛◻️◻️◻️⬛◻️◻️◻️⬛
  Since spaces 4 and 5 are locked and cannot contain tiles, any number spanning those cells must begin and end with a 5 either before or after these locked cells.
  If space 3 were not a tile the number would stretch to at least four digits that is too long to produce a product of 20 using only the digits 2 and 5.
  Therefore, space 3 must be a tile to constrain the segment length. This logic also determines the placement of the remaining tiles in the row.

• Consequently, the red region must be either 4 or 5.
  Since the clue for the first number is "product of digits is 20" and we already have 2 as one digit.
  The only two-digit combinations left are 4 × 5 or 5 × 4.

• The green region must then be 1.
  This deduction results from looking at the next clue which is "product of digits is 25."
  The prime factorization of 25 is 5 × 5.
  Valid numbers for that product include 55, 551, 155, etc.
  Since we've already allocated 4 or 5 to red the only available digit that fits reasonably in this pattern and remains unallocated is 1. Assigning 1 to green allows the number groupings to work—while also ensuring compliance with the rule that no digits may repeat within the completed grid.

Algorithmic Solution

Overview

Now with the preliminary analysis completed it is time to start thinking about the algorithm.

I opted for a relatively straight forward solution. That being:

Pre-Solving:

1. Generate All Possible Tile Arrangements

2. Filter Legal Arrangements
   For each row, discard any illegal configurations (tiles on locked spaces)

Solver:

1. Generate Region-to-Digit Mappings
   Enumerate all valid mappings of regions to digits 1–9 with respect to the adjacency rules.

2. Iterate Over All Combinations
   Apply all possible combinations of tile arrangements and mappings for the row

3. Try to solve each number in the row
   For each segment of digits between tiles:

   1. Identify the start and end of the number to solve

   2. Identify the tiles below, left and right of the number

   3. Identify which digits will be altered by each tile.

   4. Try all possible combinations of tile-values

   5. Check if the number is valid using the clue

4. Validate the Row
   If all numbers in the row are valid append the row to a list of solved rows

5. Repeat for all rows

Generating possible tile states

Possible tile arrangements are simply generated by counting in binary to 2048 (2^11) and rejecting non valid arrangements

def bit_list(n, length=11):
  bit_string = bin(n)[2:] # Cut off the "0b"
  bit_string = bit_string[::-1] # Flip the string to convert to big endian
  return [int(digit) for digit in bit_string] + [0] * (length - len(bit_string)) # Add padding

def is_valid_arrangement(tile_map):
  for i in range(len(tile_map)-1):
    # Skip if there is no tile
    if tile_map[i] == 0:
      continue


    # If a tile is at the second position, there is no space for two spaces
    if i == 1:
      return False


    # If a tile is at the second to last position, there is no space for two spaces
    if i == len(tile_map) - 2:
      return False

    # Check the offsets around the tile
    for offset in [-2, -1, 1, 2]:
      if i + offset < 0 or i + offset >= len(tile_map):
        continue

      if tile_map[i + offset] == 1:
        return False

  # If there are no conflicts, the alignment is valid
  return True

arrangements = []

for i in range(pow(2,11)):
  bits = bit_list(i)
  if is_valid_arrangement(bits):
    arrangements.append(bits)

Continuing to generating all arrangements per row:

# Map of the locked spaces
BOARD_MASK = [[0] * 11 for _ in range(11)]

BOARD_MASK[1][4] = 1
BOARD_MASK[2][4] = 1
BOARD_MASK[2][5] = 1
BOARD_MASK[3][5] = 1
BOARD_MASK[4][5] = 1
BOARD_MASK[4][6] = 1
BOARD_MASK[5][5] = 1

BOARD_MASK[3][1] = 1
BOARD_MASK[4][1] = 1
BOARD_MASK[4][2] = 1

BOARD_MASK[7][8] = 1
BOARD_MASK[7][9] = 1
BOARD_MASK[8][9] = 1

BOARD_MASK[8][4] = 1
BOARD_MASK[9][4] = 1
BOARD_MASK[9][3] = 1

#####################

def is_valid_alignment_with_row(bits, row):
  # Check if there is no 1 in the board mask
  for i in range(len(bits)):
    if bits[i] == 1 and BOARD_MASK[row][i] == 1:
      return False

arrangements_for_row = []

for i in range(11):
  valid_alignments = []
  for j in range(len(arrangements)):
    if is_valid_alignment_with_row(arrangements[j], i):
      valid_alignments.append(arrangements[j])
  arrangements_for_row.append(valid_alignments)

Generating board mappings:

# Representaion of the different regions of the board (the other way around to make it easier to work with)
INDEX_BOARD = [
  [5,5,8,8,8,8,8,8,5,5,5],
  [5,5,5,5,5,5,5,5,5,5,5],
  [5,5,5,5,6,5,6,7,7,7,7],
  [1,5,6,6,6,6,6,6,6,7,7],
  [1,5,6,6,1,1,4,4,6,4,4],
  [1,1,1,1,1,4,4,4,4,4,3],
  [1,2,2,1,2,4,4,3,3,4,3],
  [1,2,2,1,2,4,3,3,3,3,3],
  [1,1,2,2,2,2,3,3,3,0,3],
  [0,1,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0], 
]

# A mapping of region-index to neighboring region indices (from which the original region needs to be different)
difference_mapping = {
  0: [1,2,3],
  1: [0,2,4,5,6],
  2: [0,1,3,4],
  3: [0,2,4],
  4: [1,2,3,6,7],
  5: [1,6,7,8],
  6: [1,4,5,7],
  7: [4,5,6],
  8: [5],
}

from itertools import product

mappings_cache = {}

def generate_mappings(fixed, variable):
  if any(idx in fixed for idx in variable):
    raise ValueError("Variable indices contain already fixed indices.")

  key = (tuple(sorted(variable)), tuple(sorted(fixed.items())))
  if key in mappings_cache:
    return mappings_cache[key]

  all_digits = list(range(1, 10))
  results = []

  for digits in product(all_digits, repeat=len(variable)):
    candidate = dict(zip(variable, digits))
    candidate.update(fixed)

    valid = True
    for i in candidate:
      for j in candidate:
        if i != j:
          if (j in difference_mapping.get(i, [])) or (i in difference_mapping.get(j, [])):
            if candidate[i] == candidate[j]:
              valid = False
              break
      if not valid:
          break

    if valid:
      results.append(candidate)

  mappings_cache[key] = results
  return results

This is a function for generating mapping from region indices to numbers 1-9 respecting the difference rule and allowing for some indices to be fixed.

Solving a single number

def solve_number(board, number_indices, number_index, row_index, condition, down):
  """
  Tries every possible tile state for a given number section in a row and returns
  a list of boards that satisfy the condition.

  Args:
    board         : The current board.
    number_indices: A list of dictionaries with start and end indices for numbers.
    number_index  : The index of the current number in number_indices.
    row_index     : The row in which the number is located.
    condition     : A function that checks if the number is valid.
    down          : A boolean flag to inform tile placement direction.

  Returns:
    A list of boards with valid distributions or None if number_index is out of range.
  """
  if number_index >= len(number_indices):
    return None

  # Determine the section of the number we are going to solve.
  current_number_range = number_indices[number_index]
  number_start = current_number_range["start"]
  number_end = current_number_range["end"]

  solutions = []

  # Determine tile positions that may affect this number.
  block_locations = find_block_locations_for_number(board, number_start, number_end, row_index, down)
  replaced_numbers = extract_remaining_numbers(board, block_locations)

  current_solving_number = board.get_section(row_index, number_start, number_end)
  possible_tile_states = nested_count(replaced_numbers)
  mapping = map_block_locations_to_number(board, row_index, block_locations, number_start, number_end)

  for tile_state in possible_tile_states:
    candidate_number = current_solving_number.copy()
    invalid_state = False

    # Apply each tile state increment to the candidate number.
    for idx, tile_value in enumerate(tile_state):
      num_index = mapping[idx]["num_index"]
      index_into_row = number_start + num_index

      if board.is_locked_space(row_index, index_into_row):
        invalid_state = True
        break

      candidate_number[num_index] += tile_value
      if candidate_number[num_index] > 9:
        invalid_state = True
        break

    if invalid_state:
      continue

    # If candidate number meets the condition, try to distribute the tiles.
    if condition(candidate_number):
      sol_board = board.copy()
      distribution_error = False

      for idx, tile_value in enumerate(tile_state):
        tile_x, tile_y = mapping[idx]["coords"]
        direction = mapping[idx]["direction"]
        num_index = mapping[idx]["num_index"]
        index_into_row = number_start + num_index

        if board.is_locked_space(row_index, index_into_row):
          distribution_error = True
          break

        sol_board.set_distribution(tile_x, tile_y, direction, tile_value)

      if distribution_error:
        continue

      # If this is the last number in the row, mark the row solved and update locked tiles.
      if number_index == len(number_indices) - 1:
        sol_board.solved[row_index] = True
        for tile_idx, tile in enumerate(sol_board.tile_board[row_index]):
          if tile == 1:
            tile_info = sol_board.tile_info_board[row_index][tile_idx]
            if tile_info["remaining"] != 0:
              try:
                direction = "down" if down else "up"
                sol_board.set_distribution(row_index, tile_idx, direction, tile_info["remaining"])
              except Exception:
                sol_board.solved[row_index] = False
                distribution_error = True
                break

      if distribution_error:
        continue

      solutions.append(sol_board)

  return solutions

This function is responsible for solving a number within a row. It does this by finding the bounds of the number and figuring out which tiles affect which digits. Subsequently it tries all possible combinations of the tiles until the given condition is met.

Solving a row

def solve_row(board, number_indices, row_index, current_number_index, condition, down):
  boards = solve_number(board, number_indices, current_number_index, row_index, condition, down)

  if boards == None:
    return []
  if len(boards) == 0:
    return []

  results = []

  for i in range(len(boards)):
    b = boards[i]

    if b.solved[row_index]:
      numbers = []

      rules_satisfied = True


      # Check if there are no duplicate numbers in any solved row
      for index in range(len(b.number_board)):
        if b.solved[index] == False:
          continue


        _number_indices = b.row_get_number_indices(index)

        for j in range(len(_number_indices)):
          number = b.get_number(index, _number_indices[j]["start"], _number_indices[j]["end"])
          if number in numbers:
            rules_satisfied = False
          numbers.append(number)

      for j in range(len(b.solved)):
        # Check if there are no unsatisfied tiles in the already solved rows
        if b.solved[j] == True and j != row_index:
          for x in range(len(b.tile_info_board[j])):
            if b.tile_board[j][x] == 1:
              if b.tile_info_board[j][x]["remaining"] != 0:
                rules_satisfied = False
                raise Exception("Tile is not satisfied")

      if not rules_satisfied:
        continue

      results.append(b)
    else:
      results += solve_row(b, number_indices, row_index, current_number_index + 1, condition, down)
  return results

This function is used for solving a row. It works by calling solve_number until the row is solved. All solved boards are returned as results if the board has no unsatisfied tiles and no duplicates.

Solution:

10: 🟨3️⃣4️⃣2️⃣2️⃣2️⃣5️⃣🟨3️⃣2️⃣4️⃣
09: 5️⃣4️⃣🟨2️⃣2️⃣5️⃣🟨2️⃣5️⃣2️⃣🟨
08: 🟨5️⃣3️⃣4️⃣3️⃣🟨6️⃣5️⃣🟨2️⃣6️⃣
07: 7️⃣3️⃣6️⃣🟨3️⃣2️⃣🟨5️⃣4️⃣4️⃣🟨
06: 🟨5️⃣5️⃣5️⃣🟨2️⃣2️⃣🟨8️⃣1️⃣6️⃣
05: 5️⃣5️⃣🟨5️⃣5️⃣1️⃣🟨1️⃣5️⃣5️⃣🟨
04: 🟨3️⃣6️⃣7️⃣4️⃣4️⃣1️⃣2️⃣🟨1️⃣5️⃣
03: 7️⃣3️⃣7️⃣🟨9️⃣6️⃣9️⃣🟨9️⃣9️⃣🟨
02: 3️⃣4️⃣🟨4️⃣6️⃣3️⃣6️⃣8️⃣🟨8️⃣9️⃣
01: 5️⃣3️⃣5️⃣9️⃣3️⃣🟨5️⃣9️⃣9️⃣5️⃣🟨
00: 🟨4️⃣7️⃣🟨8️⃣8️⃣7️⃣🟨4️⃣3️⃣3️⃣

10: 342225 + 324
09: 54 + 225 + 252
08: 5343 + 65 + 26
07: 736 + 32 + 544
06: 555 + 22 + 816
05: 55 + 551 + 155
04: 3674412 + 15
03: 737 + 969 + 99
02: 34 + 46368 + 89
01: 53593 + 5995
00: 47 + 887 + 433

342225 + 324 + 54 + 225 + 252 + 5343 + 65 + 26 + 736 + 32 + 544 + 555 + 22 + 816 + 55 + 551 + 155 + 3674412 + 15 + 737 + 969 + 99 + 34 + 46368 + 89 + 53593 + 5995 + 47 + 887 + 433

Source Code:

https://gist.github.com/Addelec/266b70900279cbe4b64652c87d6ea156

The goal was to find the value of p so the probability of an infinite path along the binary tree (with at most one 1) existing is 1/2.

Solution:

I started out by defining f(o) as the probability that a binary tree has at most o ones.

Now there are two relevant cases to consider:

Case 1: o = 0 (no extra 1’s allowed)

For an infinite path to exist in this case the current node must be 0, which occurs with probability p. Additionally at least one of the two sub-trees must have an infinite path of 0's (or equivalently not both of them should have no path).

$$f_p(0) = p \cdot (1 - (1 - f_p(0))^2)$$

Simplifying this equation by dividing by f(0) yields:

$$f_p(0) = \frac{2p-1}{p}$$

Case 2: o = 1 (at most one 1 allowed)

Now there are two more sub-cases depending on if the current node is a 0 or 1:

• If it's a 0, there is still have one 1 left.

• If it's a 1, we need to continue using f(0).

A possible equation modelling this behavior is:

$$f_p(1) = p \cdot (1 - (1 - f_p(1))^2) + (1-p) \cdot (1 - (1 - f_p(0))^2)$$

Since f(1) should be 1/2 I simply replaced each occurrence of f(1) with 1/2.

$$\frac12 = p \cdot (1-(1-\frac12)^2)+(1-p)\cdot (1-(1-f_p(0))^2)$$

Solving results in this cubic equation:

$$0= \frac34 p^3 - \frac52 p^2+3p-1$$

After solving for p, the first 10 decimal digits are: 0.5306035754.

I had a great time working on this puzzle, and I am looking forward to the next one!

I started by building a visualizer, to better understand how the puzzle functioned. After playing around I realized the puzzle could most likely be solved by hand, so I enhanced the tool with features like automatic length counting to streamline the process.

I started by solving the small numbers in the top right corner and the 5 at the bottom, as they had only one valid configuration. Since 5 is a prime number and 1 forces the mirror to be in the top right corner, this limits where the mirror for the number 4 can go, as mirrors can't be placed in orthogonally adjacent cells. From there, I focused on the larger numbers, using prime factorization to figure out the needed segment lengths.

For example, 3087 = 3 × 3 × 7 × 7 × 7, meaning I needed either two 3-segments (or one 9-segment) and three 7-segments.

I worked on fitting the segments into the grid while resolving any conflicts. Additionally I tried to use as few mirrors as possible

Two hours of experimenting later, I found the solution and submitted it within the first 24 hours of the puzzle’s release.

I've attached the visualizer with the solution below.

• ENTER = Show Solution

• Click on a number = Enable/Disable Laser

• Click on a space = Cycle through mirror options

This article outlines the process we followed in solving this intricate puzzle.

Naive beginnings

Starting out we simply assumed that the numbers meant, we had to order the words in the two respective groups by some other metric. Since they were all alphabetically ordered which usually is a clue towards finding a different order.

So we thought about different ways to score words instinctively we looked at scrabble scoring and wrote a quick script to order the words by their scrabble score and replace the numbers with the respective words. This however proved to be a wrong assumption since multiple words had the same score so no absolute order could be determined.

Analyzing the Words

Our next approach was to simply look at and rearrange the words in hopes that some pattern might become evident. This however was not the case. We did notice that paring up the words of the two groups no words had the same length.

We tried removing the amount of letters of the shorter word from the longer one:

But as you may see this didn’t accomplish anything. Removing letters the words had in common also didn’t help.

Finally looking at the title

After hitting roadblock after roadblock we came to the conclusion that our approach was wrong. So we decided to divert more focus toward the title. Specifically the “Give or Take“ part. We were aware that “score” could also have different meanings (e.g. “film music”) however we didn’t yet see how this could be significant.

So we wrote another script to generate words one letter away from our word. We did this by using a list of English words which we subsequently normalized (sorting the letters of each word alphabetically) to achieve a lookup table of letters to possible words.

We than removed a letter form the word at every position and appended a letter to the word.

def normalize_word(word):
  return ''.join(sorted(word))

def find_words_with_distance_1(target, word_list):
    # Create dict
    word_dict = {}
    for word in word_list:
        normalized = normalize_word(word)
        if normalized not in word_dict.keys():
            word_dict[normalized] = set()
        word_dict[normalized].add(word)

    word_chars = list(normalize_word(target))
    possible_words = set()

    # Delete Letters
    for i in range(len(word_chars)):
        modified = word_chars[:i] + word_chars[i+1:]
        key = ''.join(modified)
        if key in word_dict:
            possible_words.update(word_dict[key])

    # Insert letters
    for letter in 'abcdefghijklmnopqrstuvwxyz':
        for i in range(len(word_chars) + 1):
            modified = word_chars[:i] + [letter] + word_chars[i:]
            key = normalize_word(modified)
            if key in word_dict:
                possible_words.update(word_dict[key])

    return possible_words

This left us with a giant list of words. So time to simplify.

Attempt One - Using scrabble scoring

Our first attempt to narrow down the list involved using Scrabble scores to prioritize the highest-scoring words. However, this was a flawed strategy since longer words (especially those containing "Q" and "Z") were disproportionately favored, making it ineffective for identifying a "taking" element.

Attempt Two - Recognizing an obscure Pattern

Late at night I was staring at the google sheet we set up for this puzzle when suddenly I had a epiphany. I saw that one could convert the word “premise” to “empire” and “stickers“ to “strikes”. My mind auto completed “The empire strikes back”. Which I first dismissed as a funny accident, later I saw that is was also possible to build more movie titles like “Star Wars“ and “Raiders of the lost ark“. This is were we remembered that we discussed “Top score” possibly meaning something else.

So we tried matching films to the “key” by firstly ignoring the numbers and using them only as placeholders. We later realized that all films fitting the key are listed within the Compositions by John Williams Article. So we were soon able to complete the key.

We noticed that the letters removed and added were identical when the two words shared the same number. This led us to consider whether the number represented the index of the added or removed letter within a specific phrase. This resulted in:

F I L M C O M P O S E R J W

This refers to John Williams, the composer behind the scores of these films. His name is a proper noun and also the solution to this puzzle.