@fastino-ai/pioneer-cli 0.1.0 → 0.2.1

package/workspaces/santa-2025/santa-2025-getting-started.ipynb

@@ -0,0 +1 @@
+{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":119106,"databundleVersionId":14321641,"sourceType":"competition"}],"dockerImageVersionId":31153,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Getting Started\n - Shows collision detection\n - Provides a plotting function\n - Creates a slightly optimized submission","metadata":{}},{"cell_type":"code","source":"import shapely\nprint(f'Using shapely {shapely.__version__}')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-11-05T18:27:41.198867Z","iopub.execute_input":"2025-11-05T18:27:41.199328Z","iopub.status.idle":"2025-11-05T18:27:41.204626Z","shell.execute_reply.started":"2025-11-05T18:27:41.199299Z","shell.execute_reply":"2025-11-05T18:27:41.203677Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import math\nimport os\nimport random\nfrom decimal import Decimal, getcontext\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nfrom matplotlib.patches import Rectangle\nfrom shapely import affinity, touches\nfrom shapely.geometry import Polygon\nfrom shapely.ops import unary_union\nfrom shapely.strtree import STRtree\n\npd.set_option('display.float_format', '{:.12f}'.format)\n\n# Set precision for Decimal\ngetcontext().prec = 25\nscale_factor = Decimal('1e15')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-11-03T01:27:19.506834Z","iopub.execute_input":"2025-11-03T01:27:19.507127Z","iopub.status.idle":"2025-11-03T01:27:19.975545Z","shell.execute_reply.started":"2025-11-03T01:27:19.507105Z","shell.execute_reply":"2025-11-03T01:27:19.974366Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Build the index of the submission, in the format:\n#  <trees_in_problem>_<tree_index>\n\nindex = [f'{n:03d}_{t}' for n in range(1, 201) for t in range(n)]","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-11-03T01:27:30.841923Z","iopub.execute_input":"2025-11-03T01:27:30.842367Z","iopub.status.idle":"2025-11-03T01:27:30.858219Z","shell.execute_reply.started":"2025-11-03T01:27:30.842343Z","shell.execute_reply":"2025-11-03T01:27:30.85724Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class ChristmasTree:\n    \"\"\"Represents a single, rotatable Christmas tree of a fixed size.\"\"\"\n\n    def __init__(self, center_x='0', center_y='0', angle='0'):\n        \"\"\"Initializes the Christmas tree with a specific position and rotation.\"\"\"\n        self.center_x = Decimal(center_x)\n        self.center_y = Decimal(center_y)\n        self.angle = Decimal(angle)\n\n        trunk_w = Decimal('0.15')\n        trunk_h = Decimal('0.2')\n        base_w = Decimal('0.7')\n        mid_w = Decimal('0.4')\n        top_w = Decimal('0.25')\n        tip_y = Decimal('0.8')\n        tier_1_y = Decimal('0.5')\n        tier_2_y = Decimal('0.25')\n        base_y = Decimal('0.0')\n        trunk_bottom_y = -trunk_h\n\n        initial_polygon = Polygon(\n            [\n                # Start at Tip\n                (Decimal('0.0') * scale_factor, tip_y * scale_factor),\n                # Right side - Top Tier\n                (top_w / Decimal('2') * scale_factor, tier_1_y * scale_factor),\n                (top_w / Decimal('4') * scale_factor, tier_1_y * scale_factor),\n                # Right side - Middle Tier\n                (mid_w / Decimal('2') * scale_factor, tier_2_y * scale_factor),\n                (mid_w / Decimal('4') * scale_factor, tier_2_y * scale_factor),\n                # Right side - Bottom Tier\n                (base_w / Decimal('2') * scale_factor, base_y * scale_factor),\n                # Right Trunk\n                (trunk_w / Decimal('2') * scale_factor, base_y * scale_factor),\n                (trunk_w / Decimal('2') * scale_factor, trunk_bottom_y * scale_factor),\n                # Left Trunk\n                (-(trunk_w / Decimal('2')) * scale_factor, trunk_bottom_y * scale_factor),\n                (-(trunk_w / Decimal('2')) * scale_factor, base_y * scale_factor),\n                # Left side - Bottom Tier\n                (-(base_w / Decimal('2')) * scale_factor, base_y * scale_factor),\n                # Left side - Middle Tier\n                (-(mid_w / Decimal('4')) * scale_factor, tier_2_y * scale_factor),\n                (-(mid_w / Decimal('2')) * scale_factor, tier_2_y * scale_factor),\n                # Left side - Top Tier\n                (-(top_w / Decimal('4')) * scale_factor, tier_1_y * scale_factor),\n                (-(top_w / Decimal('2')) * scale_factor, tier_1_y * scale_factor),\n            ]\n        )\n        rotated = affinity.rotate(initial_polygon, float(self.angle), origin=(0, 0))\n        self.polygon = affinity.translate(rotated,\n                                          xoff=float(self.center_x * scale_factor),\n                                          yoff=float(self.center_y * scale_factor))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-11-03T01:27:40.776774Z","iopub.execute_input":"2025-11-03T01:27:40.777556Z","iopub.status.idle":"2025-11-03T01:27:40.786334Z","shell.execute_reply.started":"2025-11-03T01:27:40.777525Z","shell.execute_reply":"2025-11-03T01:27:40.785399Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def generate_weighted_angle():\n    \"\"\"\n    Generates a random angle with a distribution weighted by abs(sin(2*angle)).\n    This helps place more trees in corners, and makes the packing less round.\n    \"\"\"\n    while True:\n        angle = random.uniform(0, 2 * math.pi)\n        if random.uniform(0, 1) < abs(math.sin(2 * angle)):\n            return angle","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-11-03T01:27:50.013056Z","iopub.execute_input":"2025-11-03T01:27:50.013383Z","iopub.status.idle":"2025-11-03T01:27:50.01847Z","shell.execute_reply.started":"2025-11-03T01:27:50.01336Z","shell.execute_reply":"2025-11-03T01:27:50.017625Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def initialize_trees(num_trees, existing_trees=None):\n    \"\"\"\n    This builds a simple, greedy starting configuration, by using the previous n-tree\n    placements, and adding more tree for the (n+1)-tree configuration. We place a tree\n    fairly far away at a (weighted) random angle, and the bring it closer to the center\n    until it overlaps. Then we back it up until it no longer overlaps.\n\n    You can easily modify this code to build each n-tree configuration completely\n    from scratch.\n    \"\"\"\n    if num_trees == 0:\n        return [], Decimal('0')\n\n    if existing_trees is None:\n        placed_trees = []\n    else:\n        placed_trees = list(existing_trees)\n\n    num_to_add = num_trees - len(placed_trees)\n\n    if num_to_add > 0:\n        unplaced_trees = [\n            ChristmasTree(angle=random.uniform(0, 360)) for _ in range(num_to_add)]\n        if not placed_trees:  # Only place the first tree at origin if starting from scratch\n            placed_trees.append(unplaced_trees.pop(0))\n\n        for tree_to_place in unplaced_trees:\n            placed_polygons = [p.polygon for p in placed_trees]\n            tree_index = STRtree(placed_polygons)\n\n            best_px = None\n            best_py = None\n            min_radius = Decimal('Infinity')\n\n            # This loop tries 10 random starting attempts and keeps the best one\n            for _ in range(10):\n                # The new tree starts at a position 20 from the center, at a random vector angle.\n                angle = generate_weighted_angle()\n                vx = Decimal(str(math.cos(angle)))\n                vy = Decimal(str(math.sin(angle)))\n\n                # Move towards center along the vector in steps of 0.5 until collision\n                radius = Decimal('20.0')\n                step_in = Decimal('0.5')\n\n                collision_found = False\n                while radius >= 0:\n                    px = radius * vx\n                    py = radius * vy\n\n                    candidate_poly = affinity.translate(\n                        tree_to_place.polygon,\n                        xoff=float(px * scale_factor),\n                        yoff=float(py * scale_factor))\n\n                    # Looking for nearby objects\n                    possible_indices = tree_index.query(candidate_poly)\n                    # This is the collision detection step\n                    if any((candidate_poly.intersects(placed_polygons[i]) and not\n                            candidate_poly.touches(placed_polygons[i]))\n                           for i in possible_indices):\n                        collision_found = True\n                        break\n                    radius -= step_in\n\n                # back up in steps of 0.05 until it no longer has a collision.\n                if collision_found:\n                    step_out = Decimal('0.05')\n                    while True:\n                        radius += step_out\n                        px = radius * vx\n                        py = radius * vy\n\n                        candidate_poly = affinity.translate(\n                            tree_to_place.polygon,\n                            xoff=float(px * scale_factor),\n                            yoff=float(py * scale_factor))\n\n                        possible_indices = tree_index.query(candidate_poly)\n                        if not any((candidate_poly.intersects(placed_polygons[i]) and not\n                                   candidate_poly.touches(placed_polygons[i]))\n                                   for i in possible_indices):\n                            break\n                else:\n                    # No collision found even at the center. Place it at the center.\n                    radius = Decimal('0')\n                    px = Decimal('0')\n                    py = Decimal('0')\n\n                if radius < min_radius:\n                    min_radius = radius\n                    best_px = px\n                    best_py = py\n\n            tree_to_place.center_x = best_px\n            tree_to_place.center_y = best_py\n            tree_to_place.polygon = affinity.translate(\n                tree_to_place.polygon,\n                xoff=float(tree_to_place.center_x * scale_factor),\n                yoff=float(tree_to_place.center_y * scale_factor),\n            )\n            placed_trees.append(tree_to_place)  # Add the newly placed tree to the list\n\n    all_polygons = [t.polygon for t in placed_trees]\n    bounds = unary_union(all_polygons).bounds\n\n    minx = Decimal(bounds[0]) / scale_factor\n    miny = Decimal(bounds[1]) / scale_factor\n    maxx = Decimal(bounds[2]) / scale_factor\n    maxy = Decimal(bounds[3]) / scale_factor\n\n    width = maxx - minx\n    height = maxy - miny\n    # this forces a square bounding using the largest side\n    side_length = max(width, height)\n\n    return placed_trees, side_length","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-11-03T01:29:10.194954Z","iopub.execute_input":"2025-11-03T01:29:10.195288Z","iopub.status.idle":"2025-11-03T01:29:10.210816Z","shell.execute_reply.started":"2025-11-03T01:29:10.195239Z","shell.execute_reply":"2025-11-03T01:29:10.209562Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def plot_results(side_length, placed_trees, num_trees):\n    \"\"\"Plots the arrangement of trees and the bounding square.\"\"\"\n    _, ax = plt.subplots(figsize=(6, 6))\n    colors = plt.cm.viridis([i / num_trees for i in range(num_trees)])\n\n    all_polygons = [t.polygon for t in placed_trees]\n    bounds = unary_union(all_polygons).bounds\n\n    for i, tree in enumerate(placed_trees):\n        # Rescale for plotting\n        x_scaled, y_scaled = tree.polygon.exterior.xy\n        x = [Decimal(val) / scale_factor for val in x_scaled]\n        y = [Decimal(val) / scale_factor for val in y_scaled]\n        ax.plot(x, y, color=colors[i])\n        ax.fill(x, y, alpha=0.5, color=colors[i])\n\n    minx = Decimal(bounds[0]) / scale_factor\n    miny = Decimal(bounds[1]) / scale_factor\n    maxx = Decimal(bounds[2]) / scale_factor\n    maxy = Decimal(bounds[3]) / scale_factor\n\n    width = maxx - minx\n    height = maxy - miny\n\n    square_x = minx if width >= height else minx - (side_length - width) / 2\n    square_y = miny if height >= width else miny - (side_length - height) / 2\n    bounding_square = Rectangle(\n        (float(square_x), float(square_y)),\n        float(side_length),\n        float(side_length),\n        fill=False,\n        edgecolor='red',\n        linewidth=2,\n        linestyle='--',\n    )\n    ax.add_patch(bounding_square)\n\n    padding = 0.5\n    ax.set_xlim(\n        float(square_x - Decimal(str(padding))),\n        float(square_x + side_length + Decimal(str(padding))))\n    ax.set_ylim(float(square_y - Decimal(str(padding))),\n                float(square_y + side_length + Decimal(str(padding))))\n    ax.set_aspect('equal', adjustable='box')\n    ax.axis('off')\n    plt.title(f'{num_trees} Trees: {side_length:.12f}')\n    plt.show()\n    plt.close()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-11-03T01:29:27.414855Z","iopub.execute_input":"2025-11-03T01:29:27.415684Z","iopub.status.idle":"2025-11-03T01:29:27.424921Z","shell.execute_reply.started":"2025-11-03T01:29:27.415655Z","shell.execute_reply":"2025-11-03T01:29:27.423953Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"tree_data = []\ncurrent_placed_trees = []  # Initialize an empty list for the first iteration\n\nfor n in range(200):\n    # Pass the current_placed_trees to initialize_trees\n    current_placed_trees, side = initialize_trees(n+1, existing_trees=current_placed_trees)\n    if (n+1) % 10 == 0:\n        plot_results(side, current_placed_trees, n+1)\n    for tree in current_placed_trees:\n        tree_data.append([tree.center_x, tree.center_y, tree.angle])\n        \ncols = ['x', 'y', 'deg']\nsubmission = pd.DataFrame(\n    index=index, columns=cols, data=tree_data).rename_axis('id')\n\nfor col in cols:\n    submission[col] = submission[col].astype(float).round(decimals=6)\n    \n# To ensure everything is kept as a string, prepend an 's'\nfor col in submission.columns:\n    submission[col] = 's' + submission[col].astype('string')\nsubmission.to_csv('sample_submission.csv')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-11-03T01:35:12.726307Z","iopub.execute_input":"2025-11-03T01:35:12.726605Z","iopub.status.idle":"2025-11-03T01:35:27.151304Z","shell.execute_reply.started":"2025-11-03T01:35:12.726586Z","shell.execute_reply":"2025-11-03T01:35:27.150143Z"}},"outputs":[],"execution_count":null}]}

package/workspaces/santa-2025/santa-2025-getting-started.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Getting Started
+#  - Shows collision detection
+#  - Provides a plotting function
+#  - Creates a slightly optimized submission
+
+# In[ ]:
+
+
+import shapely
+print(f'Using shapely {shapely.__version__}')
+
+
+# In[ ]:
+
+
+import math
+import os
+import random
+from decimal import Decimal, getcontext
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.patches import Rectangle
+from shapely import affinity, touches
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+from shapely.strtree import STRtree
+
+pd.set_option('display.float_format', '{:.12f}'.format)
+
+# Set precision for Decimal
+getcontext().prec = 25
+scale_factor = Decimal('1e15')
+
+
+# In[ ]:
+
+
+# Build the index of the submission, in the format:
+#  <trees_in_problem>_<tree_index>
+
+index = [f'{n:03d}_{t}' for n in range(1, 201) for t in range(n)]
+
+
+# In[ ]:
+
+
+class ChristmasTree:
+    """Represents a single, rotatable Christmas tree of a fixed size."""
+
+    def __init__(self, center_x='0', center_y='0', angle='0'):
+        """Initializes the Christmas tree with a specific position and rotation."""
+        self.center_x = Decimal(center_x)
+        self.center_y = Decimal(center_y)
+        self.angle = Decimal(angle)
+
+        trunk_w = Decimal('0.15')
+        trunk_h = Decimal('0.2')
+        base_w = Decimal('0.7')
+        mid_w = Decimal('0.4')
+        top_w = Decimal('0.25')
+        tip_y = Decimal('0.8')
+        tier_1_y = Decimal('0.5')
+        tier_2_y = Decimal('0.25')
+        base_y = Decimal('0.0')
+        trunk_bottom_y = -trunk_h
+
+        initial_polygon = Polygon(
+            [
+                # Start at Tip
+                (Decimal('0.0') * scale_factor, tip_y * scale_factor),
+                # Right side - Top Tier
+                (top_w / Decimal('2') * scale_factor, tier_1_y * scale_factor),
+                (top_w / Decimal('4') * scale_factor, tier_1_y * scale_factor),
+                # Right side - Middle Tier
+                (mid_w / Decimal('2') * scale_factor, tier_2_y * scale_factor),
+                (mid_w / Decimal('4') * scale_factor, tier_2_y * scale_factor),
+                # Right side - Bottom Tier
+                (base_w / Decimal('2') * scale_factor, base_y * scale_factor),
+                # Right Trunk
+                (trunk_w / Decimal('2') * scale_factor, base_y * scale_factor),
+                (trunk_w / Decimal('2') * scale_factor, trunk_bottom_y * scale_factor),
+                # Left Trunk
+                (-(trunk_w / Decimal('2')) * scale_factor, trunk_bottom_y * scale_factor),
+                (-(trunk_w / Decimal('2')) * scale_factor, base_y * scale_factor),
+                # Left side - Bottom Tier
+                (-(base_w / Decimal('2')) * scale_factor, base_y * scale_factor),
+                # Left side - Middle Tier
+                (-(mid_w / Decimal('4')) * scale_factor, tier_2_y * scale_factor),
+                (-(mid_w / Decimal('2')) * scale_factor, tier_2_y * scale_factor),
+                # Left side - Top Tier
+                (-(top_w / Decimal('4')) * scale_factor, tier_1_y * scale_factor),
+                (-(top_w / Decimal('2')) * scale_factor, tier_1_y * scale_factor),
+            ]
+        )
+        rotated = affinity.rotate(initial_polygon, float(self.angle), origin=(0, 0))
+        self.polygon = affinity.translate(rotated,
+                                          xoff=float(self.center_x * scale_factor),
+                                          yoff=float(self.center_y * scale_factor))
+
+
+# In[ ]:
+
+
+def generate_weighted_angle():
+    """
+    Generates a random angle with a distribution weighted by abs(sin(2*angle)).
+    This helps place more trees in corners, and makes the packing less round.
+    """
+    while True:
+        angle = random.uniform(0, 2 * math.pi)
+        if random.uniform(0, 1) < abs(math.sin(2 * angle)):
+            return angle
+
+
+# In[ ]:
+
+
+def initialize_trees(num_trees, existing_trees=None):
+    """
+    This builds a simple, greedy starting configuration, by using the previous n-tree
+    placements, and adding more tree for the (n+1)-tree configuration. We place a tree
+    fairly far away at a (weighted) random angle, and the bring it closer to the center
+    until it overlaps. Then we back it up until it no longer overlaps.
+
+    You can easily modify this code to build each n-tree configuration completely
+    from scratch.
+    """
+    if num_trees == 0:
+        return [], Decimal('0')
+
+    if existing_trees is None:
+        placed_trees = []
+    else:
+        placed_trees = list(existing_trees)
+
+    num_to_add = num_trees - len(placed_trees)
+
+    if num_to_add > 0:
+        unplaced_trees = [
+            ChristmasTree(angle=random.uniform(0, 360)) for _ in range(num_to_add)]
+        if not placed_trees:  # Only place the first tree at origin if starting from scratch
+            placed_trees.append(unplaced_trees.pop(0))
+
+        for tree_to_place in unplaced_trees:
+            placed_polygons = [p.polygon for p in placed_trees]
+            tree_index = STRtree(placed_polygons)
+
+            best_px = None
+            best_py = None
+            min_radius = Decimal('Infinity')
+
+            # This loop tries 10 random starting attempts and keeps the best one
+            for _ in range(10):
+                # The new tree starts at a position 20 from the center, at a random vector angle.
+                angle = generate_weighted_angle()
+                vx = Decimal(str(math.cos(angle)))
+                vy = Decimal(str(math.sin(angle)))
+
+                # Move towards center along the vector in steps of 0.5 until collision
+                radius = Decimal('20.0')
+                step_in = Decimal('0.5')
+
+                collision_found = False
+                while radius >= 0:
+                    px = radius * vx
+                    py = radius * vy
+
+                    candidate_poly = affinity.translate(
+                        tree_to_place.polygon,
+                        xoff=float(px * scale_factor),
+                        yoff=float(py * scale_factor))
+
+                    # Looking for nearby objects
+                    possible_indices = tree_index.query(candidate_poly)
+                    # This is the collision detection step
+                    if any((candidate_poly.intersects(placed_polygons[i]) and not
+                            candidate_poly.touches(placed_polygons[i]))
+                           for i in possible_indices):
+                        collision_found = True
+                        break
+                    radius -= step_in
+
+                # back up in steps of 0.05 until it no longer has a collision.
+                if collision_found:
+                    step_out = Decimal('0.05')
+                    while True:
+                        radius += step_out
+                        px = radius * vx
+                        py = radius * vy
+
+                        candidate_poly = affinity.translate(
+                            tree_to_place.polygon,
+                            xoff=float(px * scale_factor),
+                            yoff=float(py * scale_factor))
+
+                        possible_indices = tree_index.query(candidate_poly)
+                        if not any((candidate_poly.intersects(placed_polygons[i]) and not
+                                   candidate_poly.touches(placed_polygons[i]))
+                                   for i in possible_indices):
+                            break
+                else:
+                    # No collision found even at the center. Place it at the center.
+                    radius = Decimal('0')
+                    px = Decimal('0')
+                    py = Decimal('0')
+
+                if radius < min_radius:
+                    min_radius = radius
+                    best_px = px
+                    best_py = py
+
+            tree_to_place.center_x = best_px
+            tree_to_place.center_y = best_py
+            tree_to_place.polygon = affinity.translate(
+                tree_to_place.polygon,
+                xoff=float(tree_to_place.center_x * scale_factor),
+                yoff=float(tree_to_place.center_y * scale_factor),
+            )
+            placed_trees.append(tree_to_place)  # Add the newly placed tree to the list
+
+    all_polygons = [t.polygon for t in placed_trees]
+    bounds = unary_union(all_polygons).bounds
+
+    minx = Decimal(bounds[0]) / scale_factor
+    miny = Decimal(bounds[1]) / scale_factor
+    maxx = Decimal(bounds[2]) / scale_factor
+    maxy = Decimal(bounds[3]) / scale_factor
+
+    width = maxx - minx
+    height = maxy - miny
+    # this forces a square bounding using the largest side
+    side_length = max(width, height)
+
+    return placed_trees, side_length
+
+
+# In[ ]:
+
+
+def plot_results(side_length, placed_trees, num_trees):
+    """Plots the arrangement of trees and the bounding square."""
+    _, ax = plt.subplots(figsize=(6, 6))
+    colors = plt.cm.viridis([i / num_trees for i in range(num_trees)])
+
+    all_polygons = [t.polygon for t in placed_trees]
+    bounds = unary_union(all_polygons).bounds
+
+    for i, tree in enumerate(placed_trees):
+        # Rescale for plotting
+        x_scaled, y_scaled = tree.polygon.exterior.xy
+        x = [Decimal(val) / scale_factor for val in x_scaled]
+        y = [Decimal(val) / scale_factor for val in y_scaled]
+        ax.plot(x, y, color=colors[i])
+        ax.fill(x, y, alpha=0.5, color=colors[i])
+
+    minx = Decimal(bounds[0]) / scale_factor
+    miny = Decimal(bounds[1]) / scale_factor
+    maxx = Decimal(bounds[2]) / scale_factor
+    maxy = Decimal(bounds[3]) / scale_factor
+
+    width = maxx - minx
+    height = maxy - miny
+
+    square_x = minx if width >= height else minx - (side_length - width) / 2
+    square_y = miny if height >= width else miny - (side_length - height) / 2
+    bounding_square = Rectangle(
+        (float(square_x), float(square_y)),
+        float(side_length),
+        float(side_length),
+        fill=False,
+        edgecolor='red',
+        linewidth=2,
+        linestyle='--',
+    )
+    ax.add_patch(bounding_square)
+
+    padding = 0.5
+    ax.set_xlim(
+        float(square_x - Decimal(str(padding))),
+        float(square_x + side_length + Decimal(str(padding))))
+    ax.set_ylim(float(square_y - Decimal(str(padding))),
+                float(square_y + side_length + Decimal(str(padding))))
+    ax.set_aspect('equal', adjustable='box')
+    ax.axis('off')
+    plt.title(f'{num_trees} Trees: {side_length:.12f}')
+    plt.show()
+    plt.close()
+
+
+# In[ ]:
+
+
+tree_data = []
+current_placed_trees = []  # Initialize an empty list for the first iteration
+
+for n in range(200):
+    # Pass the current_placed_trees to initialize_trees
+    current_placed_trees, side = initialize_trees(n+1, existing_trees=current_placed_trees)
+    if (n+1) % 10 == 0:
+        plot_results(side, current_placed_trees, n+1)
+    for tree in current_placed_trees:
+        tree_data.append([tree.center_x, tree.center_y, tree.angle])
+
+cols = ['x', 'y', 'deg']
+submission = pd.DataFrame(
+    index=index, columns=cols, data=tree_data).rename_axis('id')
+
+for col in cols:
+    submission[col] = submission[col].astype(float).round(decimals=6)
+
+# To ensure everything is kept as a string, prepend an 's'
+for col in submission.columns:
+    submission[col] = 's' + submission[col].astype('string')
+submission.to_csv('sample_submission.csv')
+

package/workspaces/santa-2025/santa-2025-metric.ipynb

@@ -0,0 +1 @@
+{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"},"kaggle":{"accelerator":"none","dataSources":[],"dockerImageVersionId":31153,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"\"\"\"\nSanta 2025 Metric\nFor each N-tree configuration, calculate the bounding square divided by N.\nFinal score is the sum of the scores across all configurations.\n\nA scaling factor is used to maintain reasonably precise floating point\ncalculations in the shapley (v 2.1.2) library.\n\"\"\"\n\nfrom decimal import Decimal, getcontext\n\nimport pandas as pd\nfrom shapely import affinity, touches\nfrom shapely.geometry import Polygon\nfrom shapely.ops import unary_union\nfrom shapely.strtree import STRtree\n\n# Decimal precision and scaling factor\ngetcontext().prec = 25\nscale_factor = Decimal('1e18')\n\n\nclass ParticipantVisibleError(Exception):\n    pass\n\n\nclass ChristmasTree:\n    \"\"\"Represents a single, rotatable Christmas tree of a fixed size.\"\"\"\n\n    def __init__(self, center_x='0', center_y='0', angle='0'):\n        \"\"\"Initializes the Christmas tree with a specific position and rotation.\"\"\"\n        self.center_x = Decimal(center_x)\n        self.center_y = Decimal(center_y)\n        self.angle = Decimal(angle)\n\n        trunk_w = Decimal('0.15')\n        trunk_h = Decimal('0.2')\n        base_w = Decimal('0.7')\n        mid_w = Decimal('0.4')\n        top_w = Decimal('0.25')\n        tip_y = Decimal('0.8')\n        tier_1_y = Decimal('0.5')\n        tier_2_y = Decimal('0.25')\n        base_y = Decimal('0.0')\n        trunk_bottom_y = -trunk_h\n\n        initial_polygon = Polygon(\n            [\n                # Start at Tip\n                (Decimal('0.0') * scale_factor, tip_y * scale_factor),\n                # Right side - Top Tier\n                (top_w / Decimal('2') * scale_factor, tier_1_y * scale_factor),\n                (top_w / Decimal('4') * scale_factor, tier_1_y * scale_factor),\n                # Right side - Middle Tier\n                (mid_w / Decimal('2') * scale_factor, tier_2_y * scale_factor),\n                (mid_w / Decimal('4') * scale_factor, tier_2_y * scale_factor),\n                # Right side - Bottom Tier\n                (base_w / Decimal('2') * scale_factor, base_y * scale_factor),\n                # Right Trunk\n                (trunk_w / Decimal('2') * scale_factor, base_y * scale_factor),\n                (trunk_w / Decimal('2') * scale_factor, trunk_bottom_y * scale_factor),\n                # Left Trunk\n                (-(trunk_w / Decimal('2')) * scale_factor, trunk_bottom_y * scale_factor),\n                (-(trunk_w / Decimal('2')) * scale_factor, base_y * scale_factor),\n                # Left side - Bottom Tier\n                (-(base_w / Decimal('2')) * scale_factor, base_y * scale_factor),\n                # Left side - Middle Tier\n                (-(mid_w / Decimal('4')) * scale_factor, tier_2_y * scale_factor),\n                (-(mid_w / Decimal('2')) * scale_factor, tier_2_y * scale_factor),\n                # Left side - Top Tier\n                (-(top_w / Decimal('4')) * scale_factor, tier_1_y * scale_factor),\n                (-(top_w / Decimal('2')) * scale_factor, tier_1_y * scale_factor),\n            ]\n        )\n        rotated = affinity.rotate(initial_polygon, float(self.angle), origin=(0, 0))\n        self.polygon = affinity.translate(rotated,\n                                          xoff=float(self.center_x * scale_factor),\n                                          yoff=float(self.center_y * scale_factor))\n\n\n\ndef score(solution: pd.DataFrame, submission: pd.DataFrame, row_id_column_name: str) -> float:\n    \"\"\"\n    For each n-tree configuration, the metric calculates the bounding square\n    volume divided by n, summed across all configurations.\n\n    This metric uses shapely v2.1.2.\n\n    Examples\n    -------\n    >>> import pandas as pd\n    >>> row_id_column_name = 'id'\n    >>> data = [['002_0', 's-0.2', 's-0.3', 's335'], ['002_1', 's0.49', 's0.21', 's155']]\n    >>> submission = pd.DataFrame(columns=['id', 'x', 'y', 'deg'], data=data)\n    >>> solution = submission[['id']].copy()\n    >>> score(solution, submission, row_id_column_name)\n    0.877038143325...\n    \"\"\"\n\n    # remove the leading 's' from submissions\n    data_cols = ['x', 'y', 'deg']\n    submission = submission.astype(str)\n    for c in data_cols:\n        if not submission[c].str.startswith('s').all():\n            raise ParticipantVisibleError(f'Value(s) in column {c} found without `s` prefix.')\n        submission[c] = submission[c].str[1:]\n\n    # enforce value limits\n    limit = 100\n    bad_x = (submission['x'].astype(float) < -limit).any() or \\\n            (submission['x'].astype(float) > limit).any()\n    bad_y = (submission['y'].astype(float) < -limit).any() or \\\n            (submission['y'].astype(float) > limit).any()\n    if bad_x or bad_y:\n        raise ParticipantVisibleError('x and/or y values outside the bounds of -100 to 100.')\n\n    # grouping puzzles to score\n    submission['tree_count_group'] = submission['id'].str.split('_').str[0]\n\n    total_score = Decimal('0.0')\n    for group, df_group in submission.groupby('tree_count_group'):\n        num_trees = len(df_group)\n\n        # Create tree objects from the submission values\n        placed_trees = []\n        for _, row in df_group.iterrows():\n            placed_trees.append(ChristmasTree(row['x'], row['y'], row['deg']))\n\n        # Check for collisions using neighborhood search\n        all_polygons = [p.polygon for p in placed_trees]\n        r_tree = STRtree(all_polygons)\n\n        # Checking for collisions\n        for i, poly in enumerate(all_polygons):\n            indices = r_tree.query(poly)\n            for index in indices:\n                if index == i:  # don't check against self\n                    continue\n                if poly.intersects(all_polygons[index]) and not poly.touches(all_polygons[index]):\n                    raise ParticipantVisibleError(f'Overlapping trees in group {group}')\n\n        # Calculate score for the group\n        bounds = unary_union(all_polygons).bounds\n        # Use the largest edge of the bounding rectangle to make a square boulding box\n        side_length_scaled = max(bounds[2] - bounds[0], bounds[3] - bounds[1])\n\n        group_score = (Decimal(side_length_scaled) ** 2) / (scale_factor**2) / Decimal(num_trees)\n        total_score += group_score\n\n    return float(total_score)","metadata":{"_uuid":"2a1239f3-55fc-4dbb-9d3a-e90bfffa038c","_cell_guid":"4cf02a6f-b7e9-4360-892d-b1a50793eb12","collapsed":false,"jupyter":{"outputs_hidden":false},"trusted":true},"outputs":[],"execution_count":null}]}

package/workspaces/santa-2025/santa-2025-metric.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[ ]:
+
+
+"""
+Santa 2025 Metric
+For each N-tree configuration, calculate the bounding square divided by N.
+Final score is the sum of the scores across all configurations.
+
+A scaling factor is used to maintain reasonably precise floating point
+calculations in the shapley (v 2.1.2) library.
+"""
+
+from decimal import Decimal, getcontext
+
+import pandas as pd
+from shapely import affinity, touches
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+from shapely.strtree import STRtree
+
+# Decimal precision and scaling factor
+getcontext().prec = 25
+scale_factor = Decimal('1e18')
+
+
+class ParticipantVisibleError(Exception):
+    pass
+
+
+class ChristmasTree:
+    """Represents a single, rotatable Christmas tree of a fixed size."""
+
+    def __init__(self, center_x='0', center_y='0', angle='0'):
+        """Initializes the Christmas tree with a specific position and rotation."""
+        self.center_x = Decimal(center_x)
+        self.center_y = Decimal(center_y)
+        self.angle = Decimal(angle)
+
+        trunk_w = Decimal('0.15')
+        trunk_h = Decimal('0.2')
+        base_w = Decimal('0.7')
+        mid_w = Decimal('0.4')
+        top_w = Decimal('0.25')
+        tip_y = Decimal('0.8')
+        tier_1_y = Decimal('0.5')
+        tier_2_y = Decimal('0.25')
+        base_y = Decimal('0.0')
+        trunk_bottom_y = -trunk_h
+
+        initial_polygon = Polygon(
+            [
+                # Start at Tip
+                (Decimal('0.0') * scale_factor, tip_y * scale_factor),
+                # Right side - Top Tier
+                (top_w / Decimal('2') * scale_factor, tier_1_y * scale_factor),
+                (top_w / Decimal('4') * scale_factor, tier_1_y * scale_factor),
+                # Right side - Middle Tier
+                (mid_w / Decimal('2') * scale_factor, tier_2_y * scale_factor),
+                (mid_w / Decimal('4') * scale_factor, tier_2_y * scale_factor),
+                # Right side - Bottom Tier
+                (base_w / Decimal('2') * scale_factor, base_y * scale_factor),
+                # Right Trunk
+                (trunk_w / Decimal('2') * scale_factor, base_y * scale_factor),
+                (trunk_w / Decimal('2') * scale_factor, trunk_bottom_y * scale_factor),
+                # Left Trunk
+                (-(trunk_w / Decimal('2')) * scale_factor, trunk_bottom_y * scale_factor),
+                (-(trunk_w / Decimal('2')) * scale_factor, base_y * scale_factor),
+                # Left side - Bottom Tier
+                (-(base_w / Decimal('2')) * scale_factor, base_y * scale_factor),
+                # Left side - Middle Tier
+                (-(mid_w / Decimal('4')) * scale_factor, tier_2_y * scale_factor),
+                (-(mid_w / Decimal('2')) * scale_factor, tier_2_y * scale_factor),
+                # Left side - Top Tier
+                (-(top_w / Decimal('4')) * scale_factor, tier_1_y * scale_factor),
+                (-(top_w / Decimal('2')) * scale_factor, tier_1_y * scale_factor),
+            ]
+        )
+        rotated = affinity.rotate(initial_polygon, float(self.angle), origin=(0, 0))
+        self.polygon = affinity.translate(rotated,
+                                          xoff=float(self.center_x * scale_factor),
+                                          yoff=float(self.center_y * scale_factor))
+
+
+
+def score(solution: pd.DataFrame, submission: pd.DataFrame, row_id_column_name: str) -> float:
+    """
+    For each n-tree configuration, the metric calculates the bounding square
+    volume divided by n, summed across all configurations.
+
+    This metric uses shapely v2.1.2.
+
+    Examples
+    -------
+    >>> import pandas as pd
+    >>> row_id_column_name = 'id'
+    >>> data = [['002_0', 's-0.2', 's-0.3', 's335'], ['002_1', 's0.49', 's0.21', 's155']]
+    >>> submission = pd.DataFrame(columns=['id', 'x', 'y', 'deg'], data=data)
+    >>> solution = submission[['id']].copy()
+    >>> score(solution, submission, row_id_column_name)
+    0.877038143325...
+    """
+
+    # remove the leading 's' from submissions
+    data_cols = ['x', 'y', 'deg']
+    submission = submission.astype(str)
+    for c in data_cols:
+        if not submission[c].str.startswith('s').all():
+            raise ParticipantVisibleError(f'Value(s) in column {c} found without `s` prefix.')
+        submission[c] = submission[c].str[1:]
+
+    # enforce value limits
+    limit = 100
+    bad_x = (submission['x'].astype(float) < -limit).any() or \
+            (submission['x'].astype(float) > limit).any()
+    bad_y = (submission['y'].astype(float) < -limit).any() or \
+            (submission['y'].astype(float) > limit).any()
+    if bad_x or bad_y:
+        raise ParticipantVisibleError('x and/or y values outside the bounds of -100 to 100.')
+
+    # grouping puzzles to score
+    submission['tree_count_group'] = submission['id'].str.split('_').str[0]
+
+    total_score = Decimal('0.0')
+    for group, df_group in submission.groupby('tree_count_group'):
+        num_trees = len(df_group)
+
+        # Create tree objects from the submission values
+        placed_trees = []
+        for _, row in df_group.iterrows():
+            placed_trees.append(ChristmasTree(row['x'], row['y'], row['deg']))
+
+        # Check for collisions using neighborhood search
+        all_polygons = [p.polygon for p in placed_trees]
+        r_tree = STRtree(all_polygons)
+
+        # Checking for collisions
+        for i, poly in enumerate(all_polygons):
+            indices = r_tree.query(poly)
+            for index in indices:
+                if index == i:  # don't check against self
+                    continue
+                if poly.intersects(all_polygons[index]) and not poly.touches(all_polygons[index]):
+                    raise ParticipantVisibleError(f'Overlapping trees in group {group}')
+
+        # Calculate score for the group
+        bounds = unary_union(all_polygons).bounds
+        # Use the largest edge of the bounding rectangle to make a square boulding box
+        side_length_scaled = max(bounds[2] - bounds[0], bounds[3] - bounds[1])
+
+        group_score = (Decimal(side_length_scaled) ** 2) / (scale_factor**2) / Decimal(num_trees)
+        total_score += group_score
+
+    return float(total_score)
+