Trova una foresta ricoprente minima con massimo 64 nodi e 1024 archi di peso intero entro ±10^9.
def spanning_forest(count, edges):
if type(count) is not int or not 0 <= count <= 64 or type(edges) is not list or len(edges) > 1024:
raise ValueError("forest.input")
ordered = []
for edge in edges:
if type(edge) not in (list, tuple) or len(edge) != 3 or any(type(x) is not int for x in edge):
raise ValueError("forest.edge")
a, b, weight = edge
if not 0 <= a < count or not 0 <= b < count or abs(weight) > 10**9:
raise ValueError("forest.bounds")
ordered.append((weight, min(a, b), max(a, b)))
parent = list(range(count))
def root(node):
while parent[node] != node:
parent[node] = parent[parent[node]]
node = parent[node]
return node
selected, total = [], 0
for weight, a, b in sorted(ordered):
x, y = root(a), root(b)
if x != y:
parent[x] = y
selected.append((a, b, weight))
total += weight
return total, selected
Confronta il comportamento effettivo con il risultato atteso. Se una verifica fallisce, indaga la causa prima di altre modifiche.
Configura un endpoint compatibile con OpenAI o Anthropic usando URL di base e chiave API, se necessaria. Prova la connessione. Il server locale deve essere in esecuzione; gli strumenti remoti possono trasmettere dati separatamente.
Prova nodi separati, archi paralleli, cappi e parità deterministiche, rifiutando estremi errati o booleani senza modificare l’input.
def spanning_forest(count, edges):
if type(count) is not int or not 0 <= count <= 64 or type(edges) is not list or len(edges) > 1024:
raise ValueError("forest.input")
ordered = []
for edge in edges:
if type(edge) not in (list, tuple) or len(edge) != 3 or any(type(x) is not int for x in edge):
raise ValueError("forest.edge")
a, b, weight = edge
if not 0 <= a < count or not 0 <= b < count or abs(weight) > 10**9:
raise ValueError("forest.bounds")
ordered.append((weight, min(a, b), max(a, b)))
parent = list(range(count))
def root(node):
while parent[node] != node:
parent[node] = parent[parent[node]]
node = parent[node]
return node
selected, total = [], 0
for weight, a, b in sorted(ordered):
x, y = root(a), root(b)
if x != y:
parent[x] = y
selected.append((a, b, weight))
total += weight
return total, selected
Forellin offre agli sviluppatori un ambiente di programmazione con IA per Windows per esaminare il codice di elaborazione dei grafi insieme all'applicazione che vi fa affidamento. Avvia una conversazione sul progetto con la rappresentazione dell'input e il risultato necessario al chiamante. Chiedi all'assistente di esaminare come l'implementazione gestisce connessioni mancanti, archi ripetuti e ordinamento dell'output prima di proporre una modifica. Queste scelte definiscono la funzionalità quanto il calcolo centrale.
Il contesto di spanning_forest.py suggerisce un compito in cui i nodi disconnessi sono previsti anziché trattati come un tentativo fallito di collegare tutto. Potresti chiedere al modello di spiegare quali archi vengono selezionati e come il totale si rapporta a essi. Valuta la risposta rispetto a un piccolo grafo verificabile a mano, poi richiedi una modifica mirata se il contratto del risultato o la validazione richiedono correzioni.
Esegui i controlli del progetto su input connessi e disconnessi ed esamina come i nodi isolati vengono rappresentati dall'applicazione circostante. Se esistono più risultati validi, concorda se la selezione deterministica conta per il codice utilizzatore. Forellin accetta endpoint supportati compatibili con OpenAI o Anthropic, con credenziali quando necessarie. Si può scegliere un modello IA senza filtri quando offerto, ma restrizioni, strumenti e capacità di contesto dipendono comunque dal servizio configurato. L'ambiente supporta la tua indagine; gli esempi di grafi e i risultati dei test supportano l'accettazione del codice.
Solo se l'applicazione richiede un'unica struttura connessa. Per un risultato a foresta, componenti disconnesse possono essere valide. Specifica questa distinzione prima di richiedere una correzione, così l'assistente non forza connessioni che l'input non ha mai fornito.
Decidi se è accettabile qualsiasi ottimo valido o se il codice utilizzatore richiede una selezione ripetibile. Se l'ordinamento o i pareggi contano, includili nel risultato atteso e verificali esplicitamente anziché affidarti all'ordine incidentale degli input.
Usa un piccolo esempio e confronta indipendentemente gli archi selezionati con la somma dei loro pesi. Esamina anche se il chiamante si aspetta solo il totale o la struttura selezionata, perché questi output supportano comportamenti applicativi diversi.
Possono scomparire da un risultato composto solo da archi anche quando l'input li include. Controlla la rappresentazione circostante e decidi come l'applicazione deve conservare o visualizzare quei nodi, anziché presumere che gli archi selezionati descrivano ogni vertice.
Forellin · Aggiornato 2026-10-25
