Quadtreecodering van binaire rasters
Codeer een vierkant binair raster met tweemachtsbreedte tot 16 als een quadtree met uniforme bladeren.
def encode_quadtree(grid):
grid = tuple(tuple(row) for row in grid)
n = len(grid)
if not 1 <= n <= 16 or n & (n - 1) or any(len(row) != n for row in grid):
raise ValueError("grid.shape")
if any(type(v) is not int or v not in (0, 1) for row in grid for v in row):
raise ValueError("cell.binary")
def visit(x, y, size):
value = grid[y][x]
if all(grid[r][c] == value for r in range(y, y + size) for c in range(x, x + size)):
return value
half = size // 2
return (visit(x, y, half), visit(x + half, y, half),
visit(x, y + half, half), visit(x + half, y + half, half))
return visit(0, 0, n)Project
Controleer de volgorde linksboven, rechtsboven, linksonder en rechtsonder, en weiger lege, onregelmatige of niet-binaire rasters zonder ze te veranderen.
Controleer vóór het toepassen
Vergelijk het werkelijke gedrag met het verwachte resultaat. Onderzoek een mislukte controle voordat je verdergaat met wijzigingen.
Modellen
Stel een OpenAI-compatibel of Anthropic-endpoint in met de basis-URL en zo nodig een API-sleutel. Test de verbinding. Een lokale modelserver moet actief zijn; externe hulpmiddelen kunnen apart gegevens versturen.
def encode_quadtree(grid):
grid = tuple(tuple(row) for row in grid)
n = len(grid)
if not 1 <= n <= 16 or n & (n - 1) or any(len(row) != n for row in grid):
raise ValueError("grid.shape")
if any(type(v) is not int or v not in (0, 1) for row in grid for v in row):
raise ValueError("cell.binary")
def visit(x, y, size):
value = grid[y][x]
if all(grid[r][c] == value for r in range(y, y + size) for c in range(x, x + size)):
return value
half = size // 2
return (visit(x, y, half), visit(x + half, y, half),
visit(x, y + half, half), visit(x + half, y + half, half))
return visit(0, 0, n)Houd een representatiewijziging aan beide kanten begrijpelijk
QuadPollen is een Windows-programmeerwerkruimte met AI voor ontwikkelaars die de representatie van gestructureerde gegevens in een toepassing wijzigen. Open de projectmap en beschrijf het contract tussen de producerende en gebruikende code. Het verbonden gesprek kan u helpen die grens te inspecteren, de huidige representatie uit te leggen en een gericht voorstel te beoordelen voordat u wijzigingen aan een van beide kanten aanvaardt.
Een taak op basis van quadtree.py kan onderzoeken hoe een binair raster een geneste representatie wordt. Vraag welke invoergroottes worden geaccepteerd, hoe uniforme gebieden worden weergegeven en of gebruikende code op een bepaalde volgorde van kindelementen vertrouwt. Gebruik kleine rasters waarvan u de verwachte structuur onafhankelijk kunt inspecteren. Het voorbeeld geeft de softwarebeoordeling een concrete basis; het vormt geen ingebouwde ruimtelijke database of dienst voor opslagoptimalisatie.
U kunt een ongefilterd AI-model selecteren via een ondersteund OpenAI-compatibel of Anthropic-eindpunt wanneer de dienst er een beschikbaar stelt. Configureer de vereiste verbindingsinstellingen en onderzoek de daadwerkelijke ondersteuning voor hulpmiddelen van het model. Toets de voorgestelde wijziging aan producerende en gebruikende code en voer daarna tests uit met zowel uniforme als gemengde gegevens. De bedoelde representatie behouden is even belangrijk als geldige invoer accepteren, vooral wanneer een compacte codering een volgordefout moeilijk zichtbaar maakt in gewone toepassingsuitvoer.
Vragen over representatiewijzigingen
- Wat maakt een klein raster bruikbaar voor beoordeling?
Gebruik een raster met zichtbaar verschillende gebieden, zodat een volgordefout de verwachte structuur verandert. Neem een uniform raster als afzonderlijk geval op. Geef de bedoelde representatie expliciet, in plaats van de nieuwe encoder zijn eigen verwachte resultaat te laten genereren.
- Kan de representatie veranderen zonder de gebruikende code bij te werken?
Alleen als aan het contract daarvan voldaan blijft. Inspecteer code die posities van kindelementen, bladwaarden of nesting leest voordat u een coderingswijziging aanvaardt. Dat producerende code haar eigen tests doorstaat, toont geen compatibiliteit met opgeslagen gegevens of andere toepassingsonderdelen aan.
- Moeten grotere invoerformaten automatisch worden geaccepteerd?
Nee. Onderzoek eerst waarom de bestaande grenzen er zijn en wat de aanroepende code vereist. Grotere structuren kunnen het resourcegebruik en de validatiebehoeften veranderen. Behandel die uitbreiding als een bewuste vereiste met bijbehorende controles, niet als een neveneffect van herstructurering.
- Hoe beoordeel ik moeilijk leesbare uitvoer?
Begin met kleine invoer en vergelijk elk teruggegeven gebied met de oorspronkelijke gegevens. Vraag om een uitleg gekoppeld aan posities, niet om een algemene beschrijving. Controleer daarna het gebruikende gedrag, zodat de betekenis van de representatie over de grens heen consistent blijft.
QuadPollen · Bijgewerkt 2026-10-25
