Étiquette les solutions

Les tags d'analyseur servent à identifier comment une solution a été résolue.

Ces tags peuvent ensuite servir à :

  • Lier une solution à des approches
  • Lier une solution à des concepts
  • Rechercher des solutions portant certains tags

Format

Un tag est une string au format suivant : <category>:<thing>.

Nous prenons en charge quatre catégories, du niveau le plus élevé au plus bas :

Catégorie Description Spécificité Exemples
paradigm Un paradigme de programmation Très haut niveau, pas spécifique à un parcours imperative, functional
technique Une technique utilisée Haut niveau, la plupart ne sont pas spécifiques à un parcours recursion, immutability
construct Une construction du langage Beaucoup ne sont pas spécifiques à un parcours bitwise-and, for-loop
uses Un usage propre à un langage, comme les types ou les méthodes Bas niveau, spécifique à un parcours DateTime.add_seconds, IEnumerable

Quelques exemples de tags :

  • paradigm:functional
  • technique:recursion
  • construct:bitwise-and
  • uses:DateTime.add_seconds

Tags couramment utilisés

Bien que chaque parcours soit libre d'associer les tags qu'il veut aux solutions, nous recommandons d'utiliser autant que possible la liste de tags couramment utilisés ci-dessous. Un ensemble de tags commun nous permet de faire des choses sympathiques, comme relier des solutions entre parcours.

Paradigme

Tag Description
paradigm:array utilise la programmation par tableaux.
paradigm:declarative utilise la programmation déclarative.
paradigm:functional utilise la programmation fonctionnelle.
paradigm:generic utilise la programmation générique.
paradigm:imperative utilise la programmation impérative.
paradigm:logic utilise la programmation logique.
paradigm:meta utilise la métaprogrammation.
paradigm:object-oriented utilise la programmation orientée objet.
paradigm:procedural utilise la programmation procédurale.
paradigm:reflective utilise la programmation réflective.
paradigm:stack-oriented utilise la programmation orientée pile.

Techniques

Tag Description
technique:bit-manipulation manipule les bits, généralement à l'aide d'opérateurs bit à bit (par ex. AND, XOR ou décalage à gauche)
technique:bit-shifting décale les bits d'un nombre
technique:boolean-logic exécute de la logique booléenne (AND, OR, NOT)
technique:composition utilise la composition
technique:concurrency exécute du code de façon concurrente
technique:enumeration énumère des valeurs
technique:error-handling gère les erreurs
technique:exceptions intercepte ou lance des exceptions
technique:function-composition utilise la composition de fonctions
technique:generator utilise un générateur
technique:higher-order-functions utilise des fonctions d'ordre supérieur
technique:immutability utilise l'immuabilité
technique:immutable-collection utilise une collection dont le contenu est immuable
technique:inheritance utilise l'héritage
technique:laziness produit des valeurs de façon paresseuse, uniquement quand c'est nécessaire
technique:locks utilise des verrous pour obtenir un accès exclusif à des ressources
technique:looping utilise des boucles
technique:math utilise des mathématiques
technique:memory-management gère la mémoire
technique:ordering ordonne des données
technique:parallelism exécute du code en parallèle
technique:parser analyse des données
technique:pointers utilise des pointeurs
technique:randomness utilise de l'aléatoire
technique:recursion utilise la récursivité
technique:regular-expression utilise des expressions régulières
technique:short-circuiting utilise l'évaluation en court-circuit pour éviter des évaluations inutiles
technique:sorted-collection utilise une collection dont les éléments sont toujours triés
technique:sorting trie des données
technique:tail-call-optimization utilise l'optimisation des appels terminaux pour une récursivité efficace
technique:type-conversion convertit des valeurs d'un type vers un autre
technique:unsafe utilise du code non sûr (par exemple de l'arithmétique de pointeurs)

Constructions

Tag Description
construct:abstract-class définit une classe abstraite
construct:abstract-method définit une méthode abstraite
construct:add-assignment combine l'addition avec l'affectation
construct:add utilise l'addition
construct:array utilise ou déclare un tableau
construct:assignment affecte ou lie une valeur à une variable ou à un nom
construct:async-await utilise async/await
construct:attribute annote un membre avec des métadonnées
construct:auto-implemented-property définit une propriété à implémentation automatique
construct:big-integer utilise un grand entier
construct:binary-number définit un nombre en notation binaire
construct:bit-array utilise ou déclare un tableau de bits
construct:bitwise-and-assignment combine un AND bit à bit avec l'affectation
construct:bitwise-and exécute un AND bit à bit
construct:bitwise-left-shift-assignment combine un décalage bit à bit à gauche avec l'affectation
construct:bitwise-left-shift exécute un décalage bit à bit à gauche
construct:bitwise-not exécute un NOT bit à bit
construct:bitwise-or-assignment combine un OR bit à bit avec l'affectation
construct:bitwise-or exécute un OR bit à bit
construct:bitwise-right-shift-assignment combine un décalage bit à bit à droite avec l'affectation
construct:bitwise-right-shift exécute un décalage bit à bit à droite
construct:bitwise-xor-assignment combine un XOR bit à bit avec l'affectation
construct:bitwise-xor exécute un XOR bit à bit
construct:block définit un bloc contenant une liste d'instructions
construct:boolean définit ou utilise une valeur booléenne
construct:boxing utilise le boxing
construct:break sort d'une boucle
construct:byte utilise un entier non signé de 8 bits
construct:catch intercepte une exception
construct:char utilise un caractère
construct:checked-arithmetic utilise de l'arithmétique vérifiée (qui protège contre les débordements)
construct:class définit une classe
construct:collection-initializer définit les valeurs d'une collection via un initialiseur
construct:command définit une commande
construct:comment définit un commentaire
construct:comparison-chaining enchaîne des appels de comparaison
construct:comparison compare deux valeurs selon leur ordre relatif
construct:complex-number utilise un nombre complexe
construct:computed-string définit une string calculée
construct:concatenation concatène des valeurs
construct:conditional-access accède à une méthode de façon conditionnelle
construct:conditional-operator utilise un opérateur conditionnel ternaire
construct:conditional exécute du code de façon conditionnelle
construct:constant définit une valeur constante (immuable)
construct:constructor définit un constructeur
construct:continue passe à l'itération suivante d'une boucle
construct:conversion-operator définit un opérateur de conversion
construct:copy copie une valeur
construct:coroutine définit ou utilise une coroutine
construct:custom-attribute définit un attribut personnalisé
construct:date-time utilise une valeur qui représente une combinaison de date et d'heure
construct:date utilise une valeur qui représente une date (sans heure)
construct:decimal utilise un nombre à virgule flottante de 128 bits
construct:decrement décrémente une valeur
construct:default-interface-implementation définit une implémentation par défaut dans une interface
construct:default définit une valeur par défaut (par ex. pour un paramètre)
construct:destructuring déstructure une valeur en ses parties
construct:dictionary-comprehension crée un dictionnaire via une compréhension
construct:dictionary utilise ou définit un dictionnaire ou une map
construct:discard utilise la valeur spéciale discard
construct:divide-assignment combine la division avec l'affectation
construct:divide utilise la division
construct:do-while-loop utilise une boucle do-while
construct:double utilise un nombre à virgule flottante de 64 bits
construct:else définit une branche else
construct:enum définit ou utilise un enum (énumération de valeurs)
construct:equality compare l'égalité de deux valeurs
construct:error définit ou utilise une erreur
construct:event définit ou utilise des événements
construct:exception définit ou utilise des exceptions
construct:explicit-conversion convertit explicitement d'un type vers un autre
construct:explicit-import importe uniquement certaines fonctionnalités
construct:exponentiation calcule la puissance d'une valeur
construct:expression-bodied-member définit un membre à corps d'expression
construct:extension-method définit une méthode d'extension
construct:field-access accède à un champ
construct:field définit un champ
construct:finally utilise finally pour garantir qu'un bloc de code donné s'exécute toujours
construct:flags-enum définit ou utilise un enum de drapeaux
construct:float utilise un nombre à virgule flottante de 32 bits
construct:floating-point-number utilise un nombre à virgule flottante
construct:for-loop utilise une boucle for
construct:foreach utilise une boucle foreach
construct:function-overloading utilise la surcharge de fonctions
construct:function définit une fonction
construct:generator définit une fonction ou une méthode génératrice
construct:generic-function définit une fonction paramétrée par un ou plusieurs types
construct:generic-method définit une méthode paramétrée par un ou plusieurs types
construct:generic-type définit un type paramétré par un ou plusieurs types
construct:getter définit un accesseur
construct:global-function définit une fonction disponible globalement
construct:global-variable définit une variable disponible globalement
construct:header définit un fichier d'en-tête
construct:hexadecimal-number définit un nombre en notation hexadécimale
construct:if utilise une instruction if
construct:implicit-conversion convertit implicitement d'un type vers un autre
construct:implicit-loop parcourt implicitement une collection de valeurs
construct:implicit-return renvoie une valeur de façon implicite
construct:import importe des fonctionnalités implémentées ailleurs (par ex. depuis un espace de noms ou un module)
construct:increment incrémente une valeur
construct:index-operator définit un opérateur pour indexer un objet
construct:indexer définit ou utilise un indexeur
construct:indexing accède à une valeur par son indice
construct:inequality compare l'inégalité de deux valeurs
construct:infix-operator définit un opérateur infixe
construct:initialization initialise un objet après sa création
construct:initializer-list initialise les valeurs des champs d'un objet
construct:initializer initialise un objet
construct:instance crée ou utilise une instance d'un type
construct:instantiation crée une instance d'un type
construct:int utilise un entier signé de 32 bits
construct:integral-number utilise un nombre entier
construct:interface définit une interface
construct:invocation appelle une méthode ou une fonction
construct:iterator définit une fonction ou une méthode sur laquelle on peut itérer
construct:jagged-array utilise un tableau en escalier (un tableau de tableaux)
construct:lambda définit une lambda (aussi appelée « fonction anonyme »)
construct:linked-list utilise une liste chaînée
construct:linq utilise LINQ
construct:list-comprehension construit une liste via une compréhension
construct:list utilise une liste
construct:local-function définit une fonction locale
construct:local-variable définit une variable locale
construct:lock utilise un verrou
construct:logical-and exécute un AND logique
construct:logical-not exécute un NOT logique
construct:logical-or exécute un OR logique
construct:long utilise un entier signé de 64 bits
construct:loop définit une boucle
construct:macro définit une macro
construct:membership-test teste l'appartenance d'une valeur à une autre valeur
construct:metatable définit une métatable
construct:method-chaining enchaîne plusieurs appels de méthode
construct:method-overloading utilise la surcharge de méthodes
construct:method-override définit une méthode redéfinie
construct:method définit une méthode
construct:module définit un module (regroupement de code)
construct:modulo-assignment combine le reste de la division avec l'affectation
construct:modulo utilise le reste de la division
construct:multi-dimensional-array utilise un tableau à plusieurs dimensions
construct:multiline-string définit une string sur plusieurs lignes
construct:multiple-assignment affecte plusieurs valeurs en une seule fois
construct:multiple-dispatch utilise la répartition multiple
construct:multiply-assignment combine la multiplication avec l'affectation
construct:multiply utilise la multiplication
construct:named-argument passe un argument par son nom
construct:namespace définit un espace de noms (regroupement de code)
construct:nested-function définit une fonction imbriquée
construct:nested-type définit un type imbriqué
construct:nesting utilise l'imbrication
construct:nint utilise un entier signé propre à la plateforme (32 ou 64 bits)
construct:nuint utilise un entier non signé propre à la plateforme (32 ou 64 bits)
construct:null utilise null ou nil pour représenter l'absence de valeur
construct:nullability gère les valeurs null ou nil
construct:number utilise un nombre (signé ou non signé)
construct:object-initializer définit les valeurs d'un objet via un initialiseur
construct:octal-number définit un nombre en notation octale
construct:operator-overloading utilise la surcharge d'opérateurs
construct:option utilise un type option
construct:optional-parameter définit un paramètre facultatif
construct:overflow utilise un débordement arithmétique
construct:parameter définit un paramètre
construct:parenthesized-expression entoure une expression de parenthèses
construct:pattern-matching utilise le filtrage par motifs
construct:pattern définit un motif utilisé dans le filtrage par motifs
construct:pipe-backward utilise un pipe inversé
construct:pipe-forward utilise un pipe
construct:pipeline définit un pipeline
construct:point-free définit des fonctions sans les arguments sur lesquels elles opèrent
construct:pointer utilise un pointeur
construct:postfix-decrement décrémente une valeur en notation postfixée
construct:postfix-increment incrémente une valeur en notation postfixée
construct:prefix-decrement décrémente une valeur en notation préfixée
construct:prefix-increment incrémente une valeur en notation préfixée
construct:print affiche une valeur dans la console
construct:property définit une propriété (accesseur et mutateur)
construct:query-expression interroge des données via une expression
construct:queue utilise une file
construct:range définit un intervalle
construct:read-only définit une valeur en lecture seule
construct:record définit un record
construct:regular-expression définit ou utilise une expression régulière
construct:result utilise un type résultat
construct:return-type définit le type de retour d'une fonction ou d'une méthode
construct:return renvoie depuis une fonction ou une méthode
construct:sbyte utilise un entier signé de 8 bits
construct:scientific-notation-number définit un nombre en notation scientifique
construct:set-comprehension crée un ensemble via une compréhension
construct:set utilise un ensemble
construct:setter définit un mutateur
construct:short utilise un entier signé de 16 bits
construct:slice utilise une tranche
construct:stack utilise une pile
construct:static-field définit un champ statique
construct:static-method définit une méthode statique
construct:string-formatting construit une string à partir d'une chaîne de format
construct:string-interpolation définit une string interpolée
construct:string définit une string
construct:struct définit une structure
construct:subtract-assignment combine la soustraction avec l'affectation
construct:subtract utilise la soustraction
construct:sum-type définit un type somme
construct:switch utilise un switch
construct:table définit une table
construct:template-alias définit un alias pour un gabarit
construct:template-parameter définit un paramètre de gabarit
construct:template définit un gabarit
construct:throw lance une exception
construct:time utilise un objet qui représente l'heure
construct:try gère une exception explicitement
construct:tuple utilise un tuple
construct:type-alias définit un alias pour un type
construct:type-conversion convertit (transtype) une valeur vers un autre type
construct:type-extension étend un type avec de nouvelles fonctionnalités
construct:type-inference déduit automatiquement le type d'une valeur ou d'une fonction
construct:type-test teste si une valeur a un type donné
construct:uint utilise un entier non signé de 32 bits
construct:ulong utilise un entier non signé de 64 bits
construct:unary-minus utilise un moins unaire
construct:unary-plus utilise un plus unaire
construct:underscored-number utilise un nombre dont les tirets bas servent de séparateurs de chiffres
construct:union-type définit un type union
construct:user-defined-exception définit une exception personnalisée, définie par l'utilisateur
construct:ushort utilise un entier non signé de 16 bits
construct:using-directive utilise du code provenant d'un autre fichier
construct:using-statement affecte et libère une valeur via l'instruction using
construct:varargs définit un paramètre qui accepte zéro ou plusieurs valeurs
construct:variable déclare une variable
construct:vector utilise un vecteur
construct:verbatim-string utilise une string verbatim (sans séquences d'échappement)
construct:virtual-method définit une méthode virtuelle
construct:visibility-modifiers spécifie la visibilité d'une construction (par ex. une méthode ou une classe)
construct:while-loop utilise une boucle while
construct:yield produit une valeur dans une boucle de façon paresseuse

Utilisations

Comme cette catégorie est propre à chaque langage, il n'y a pas de tags couramment utilisés ici.