ForHosting KIT · Mathématiques

Calculateur de degré de sommet

Collez une liste d'arcs et obtenez le degré de chaque sommet : dans le triangle A→B, B→C, C→A, chaque sommet a un degré entrant de 1, sortant de 1 et total de 2, et les degrés font 6, le double des 3 arcs. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Le degré d'un sommet est le premier nombre que l'on calcule en ouvrant un problème de théorie des graphes, en dessinant un digraphe de dépendances ou en auditer un instantané de réseau social. Ce calculateur de degré de sommet accepte une liste d'arêtes, totalise le degré entrant et le degré sortant de chaque sommet qui apparaît, rapporte le degré total comme leur somme sur les graphes orientés, et vérifie le classique lemme des poignées de main : la somme de tous les degrés égale le double du nombre d'arêtes. Le mode orienté traite chaque ligne comme un arc d'une source vers une cible ; le mode non orienté traite chaque ligne comme un lien bidirectionnel et compte les boucles avec la convention habituelle +2.

Ce que signifient degré, degré entrant et sortant sur une liste d'arêtes

En théorie des graphes, le degré d'un sommet est le nombre d'extrémités d'arête qui touchent ce sommet. Sur un graphe orienté—aussi appelé digraphe—chaque arête est un couple ordonné d'une queue vers une tête. Le degré sortant d'un sommet est le nombre d'arêtes qui le quittent ; le degré entrant est le nombre d'arêtes qui y entrent ; le degré total est la somme du degré entrant et du degré sortant.

Sur un graphe non orienté chaque arête est une paire non ordonnée, de sorte qu'un sommet a un seul degré égal au nombre d'extrémités incidentes, et les manuels écrivent souvent que degré entrant égale degré sortant égale ce degré commun lorsque le cas non orienté utilise la même notation.

Les boucles comptent : sur un digraphe une boucle contribue un au degré entrant et un au sortant ; sur un graphe non orienté une boucle contribue deux au degré car les deux extrémités de la boucle sont sur le même sommet. Les multi-arêtes sont autorisées : deux arcs parallèles de A vers B comptent tous les deux. Les sommets qui n'apparaissent jamais dans la liste d'arêtes sont absents de la sortie ; seuls ceux qui participent à au moins une arête sont rapportés.

Cette capacité ne calcule ni composantes connexes, ni plus courts chemins, ni matrices d'adjacence ; elle répond seulement aux comptages d'incidence et à l'identité globale des poignées de main que tout cours d'introduction prouve en premier.

Contrat d'entrée, forme de la réponse et contrôle du lemme

L'indicateur optionnel directed vaut true par défaut. Lorsque directed est true, chaque ligne est un arc orienté : le degré sortant s'incrémente en from, l'entrant en to, et le degré est leur somme. Lorsque directed est false, chaque ligne est non orientée : les deux extrémités gagnent un degré (une boucle en gagne deux), et degré entrant et sortant sont égaux au degré pour que la même forme de réponse serve aux deux modes.

Le lemme des poignées de main—aussi appelé handshaking lemma—affirme que la somme de tous les degrés de sommets égale le double du nombre d'arêtes. Pour les digraphes le même parcours implique aussi que la somme des degrés entrants et celle des degrés sortants égalent chacune le nombre d'arêtes ; la réponse expose ces sommes pour que vous puissiez affirmer les trois identités en un seul appel. Les listes d'arêtes vides sont valides et renvoient zéro sommets avec un handshake vrai.

Où un calculateur de degré de sommet trouve son utilité

Les salles de classe et les plateformes de tutorat utilisent un calculateur de degré de sommet pour que les apprenants vérifient les tableaux de degré entrant et sortant sur des graphes de devoirs arbitraires sans mal compter les multi-arêtes à la main. Les générateurs d'examens et les auto-correcteurs LMS ont besoin d'un oracle déterministe qui marque le lemme des poignées de main comme vrai lorsque la somme des degrés égale le double du nombre d'arêtes et qui rejette les lignes mal formées au lieu d'inventer silencieusement des sommets.

Les ingénieurs logiciels qui modélisent des dépendances de paquets, des graphes d'appels ou le trafic de microservices commencent souvent par les distributions de degré : quels services ont un fort fan-out sortant, quels nœuds puits ont un fort degré entrant, et si une exportation de données a brisé par accident l'identité des poignées de main. Les analystes de réseaux et les notebooks de graphes sociaux utilisent les mêmes décomptes avant de calculer des scores de centralité plus coûteux. Une validation échouée ne consomme pas le solde.

Gardez les listes d'arêtes compactes, figez le tableau ordonné de sommets dans les tests, et vous obtenez des tableaux de degrés reproductibles sans déployer une bibliothèque de graphes complète pour un premier audit d'incidence.

Cas d’usage

Tableaux de degré pour devoirs et examens

Collez une liste d'arêtes de digraphe ou non orientée et vérifiez le degré entrant, sortant et le degré de chaque sommet face aux solutions du manuel, y compris la somme des poignées de main.

Oracles LMS et de correction

Notez des items de théorie des graphes avec un contrôle déterministe : la somme des degrés égale le double des arêtes, et les étiquettes de sommet vides sont rejetées.

Audits de dépendances et de fan-out de trafic

Totalisez les degrés entrants et sortants de services ou de paquets à partir d'une liste exportée avant d'exécuter hors ligne une centralité ou une détection de cycles.

Questions fréquentes

Comment calculer le degré entrant et sortant à partir d'une liste d'arêtes ?

Envoyez edges sous la forme [{from, to}, ...]. Avec directed true (par défaut), le degré sortant compte les lignes où le sommet est from et l'entrant où il est to ; le degré est leur somme.

Qu'est-ce que le lemme des poignées de main ?

Le handshaking lemma affirme que la somme de tous les degrés de sommets égale le double du nombre d'arêtes.

Comment compte-t-on les graphes non orientés et les boucles ?

Mettez directed à false. Chaque arête non orientée ajoute un au degré aux deux extrémités ; une boucle en ajoute deux. Degré entrant et sortant sont égaux au degré pour une forme de réponse uniforme.

Les sommets isolés sont-ils inclus ?

Non. Seuls les sommets qui apparaissent comme extrémité d'au moins une arête sont listés. Les isolés ne touchent pas la liste d'arêtes, donc n'affectent pas la somme des poignées de main.

Les arcs répétés entre deux mêmes sommets comptent-ils deux fois ?

Oui. Les arcs multiples sont acceptés : chacun des deux arcs de A vers B ajoute un au degré sortant de A et un au degré entrant de B. Rien n'est fusionné ni supprimé en silence.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/dev/graph-degree

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/dev/graph-degree \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"edges":[{"from":"A","to":"B"},{"from":"B","to":"C"},{"from":"C","to":"A"}]}'

const res = await fetch("https://api.kit.forhosting.com/dev/graph-degree", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "edges": [
      {
        "from": "A",
        "to": "B"
      },
      {
        "from": "B",
        "to": "C"
      },
      {
        "from": "C",
        "to": "A"
      }
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/graph-degree",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "edges": [
        {
            "from": "A",
            "to": "B"
        },
        {
            "from": "B",
            "to": "C"
        },
        {
            "from": "C",
            "to": "A"
        }
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/graph-degree", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"edges":[{"from":"A","to":"B"},{"from":"B","to":"C"},{"from":"C","to":"A"}]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"edges":[{"from":"A","to":"B"},{"from":"B","to":"C"},{"from":"C","to":"A"}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/graph-degree", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "edges": [
    {
      "from": "A",
      "to": "B"
    },
    {
      "from": "B",
      "to": "C"
    },
    {
      "from": "C",
      "to": "A"
    }
  ]
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.graph_degree",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Les lignes d'arêtes invalides échouent avec invalid_input et ne sont pas facturées.

Contrat d'entrée, forme de la réponse et contrôle du lemme

Envoyez un corps JSON en POST avec edges, un tableau d'objets portant chacun from et to (le gestionnaire accepte aussi les alias source ou u pour la queue et target ou v pour la tête). Les étiquettes de sommet peuvent être des chaînes ou des nombres finis et sont normalisées en chaînes tronquées ; les étiquettes vides et les lignes non objets échouent avec invalid_input en nommant le champ. En cas de succès le corps inclut directed, edge_count, vertex_count, un tableau vertices d'enregistrements avec id, in_degree, out_degree et degree, les agrégats sum_in_degree, sum_out_degree et sum_degree, handshake_holds, handshake_expected (toujours le double de edge_count) et une courte chaîne formula. Au plus cinq mille arêtes sont acceptées par requête afin de borner les chemins navigateur et worker.

Où un calculateur de degré de sommet trouve son utilité

Les sites de contenu qui se positionnent sur calculateur de degré de sommet bénéficient d'un outil gratuit dans le navigateur dont la logique pure coïncide octet par octet avec l'API payante. Comme l'implémentation est pure parse de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant.

Questions techniques

Combien coûte le calculateur de degré de sommet ?

L'outil navigateur est gratuit. Les requêtes API utilisent le solde KIT prépayé à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →

Lancer gratuitement

Ce que signifient degré, degré entrant et sortant sur une liste d'arêtes

Contrat d'entrée, forme de la réponse et contrôle du lemme

Où un calculateur de degré de sommet trouve son utilité

Cas d’usage

Tableaux de degré pour devoirs et examens

Oracles LMS et de correction

Audits de dépendances et de fan-out de trafic

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Erreurs

Notes techniques

Contrat d'entrée, forme de la réponse et contrôle du lemme

Où un calculateur de degré de sommet trouve son utilité

Questions techniques

merci