CComponentWisp
Fluxuri de lucru

Fluxuri de programare · Componente orientate tare conexe

03
Produs

Fluxuri de lucru

Împarte un graf orientat de cel mult 64 de vârfuri în componente tare conexe. Testează cicluri, vârfuri izolate și intrare goală, respinge membri invalizi fără schimbarea mulțimilor de adiacență.

01

Descarcă aplicația

Selectează un dosar și cere asistentului să citească fișierele relevante înainte de editare. Definește obiectivul și limitele sarcinii.

02

Deschide dosarul proiectului

Alege un endpoint compatibil. Instrumentele disponibile și calitatea răspunsurilor depind de modelul și serverul configurate.

03

Conectează și testează modelul

Verifică modificările și rezultatele comenzilor. Rulează verificările proiectului înainte de acceptare; codul generat nu este testat automat.

04

Verifică modificările și rulează testele

Compară comportamentul real cu rezultatul așteptat. Dacă o verificare eșuează, cercetează cauza înainte de alte modificări.

Componente orientate tare conexe

Fluxuri de lucru
def strong_components(graph):
    if type(graph) is not list or len(graph) > 64:
        raise ValueError("scc.graph")
    n = len(graph)
    if any(type(row) is not set or any(type(v) is not int or not 0 <= v < n for v in row) for row in graph):
        raise ValueError("scc.edge")
    seen, order = set(), []
    for start in range(n):
        if start in seen:
            continue
        seen.add(start)
        stack = [(start, iter(sorted(graph[start])))]
        while stack:
            node, edges = stack[-1]
            target = next(edges, None)
            if target is None:
                order.append(node)
                stack.pop()
            elif target not in seen:
                seen.add(target)
                stack.append((target, iter(sorted(graph[target]))))
    reverse = [set() for _ in graph]
    for node, edges in enumerate(graph):
        for target in edges:
            reverse[target].add(node)
    seen, result = set(), []
    for start in reversed(order):
        if start in seen:
            continue
        group, pending = [], [start]
        seen.add(start)
        while pending:
            node = pending.pop()
            group.append(node)
            for target in reverse[node]-seen:
                seen.add(target)
                pending.append(target)
        result.append(sorted(group))
    return sorted(result)

Verifică înainte de aplicare. Verifică modificările și rezultatele comenzilor. Rulează verificările proiectului înainte de acceptare; codul generat nu este testat automat.

Spațiu de programare cu AI

Următoarea idee începe aici.

Descarcă pentru Windows ↗