Assegnare i tag alle soluzioni

I tag degli analyzer servono a identificare come è stata risolta una soluzione.

Questi tag possono poi essere usati per:

  • Collegare una soluzione agli approcci
  • Collegare una soluzione ai concetti
  • Cercare soluzioni con determinati tag

Formato

Un tag è una stringa formattata così: <category>:<thing>.

Supportiamo quattro categorie diverse, dal livello più alto a quello più basso:

Categoria Descrizione Specificità Esempi
paradigm Un paradigma di programmazione Di altissimo livello, non specifico del track imperative, functional
technique Una tecnica utilizzata Di alto livello, per la maggior parte non specifici del track recursion, immutability
construct Un costrutto del linguaggio Molti non saranno specifici del track bitwise-and, for-loop
uses Uso specifico del linguaggio, come tipi o metodi Di basso livello, specifico del track DateTime.add_seconds, IEnumerable

Alcuni esempi di tag:

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

Tag di uso comune

Sebbene i track siano liberi di taggare le soluzioni come preferiscono, ti consigliamo di provare a usare, quando possibile, la lista di tag di uso comune riportata qui sotto. Usare un insieme comune di tag ci permetterà di fare cose interessanti, come collegare le soluzioni tra track diversi.

Paradigma

Tag Descrizione
paradigm:array usa la programmazione ad array.
paradigm:declarative usa la programmazione dichiarativa.
paradigm:functional usa la programmazione funzionale.
paradigm:generic usa la programmazione generica.
paradigm:imperative usa la programmazione imperativa.
paradigm:logic usa la programmazione logica.
paradigm:meta usa la metaprogrammazione.
paradigm:object-oriented usa la programmazione orientata agli oggetti.
paradigm:procedural usa la programmazione procedurale.
paradigm:reflective usa la programmazione riflessiva.
paradigm:stack-oriented usa la programmazione orientata allo stack.

Tecniche

Tag Descrizione
technique:bit-manipulation manipola i bit, di solito tramite operatori bitwise (ad es. AND, XOR o shift a sinistra)
technique:bit-shifting sposta i bit in un numero
technique:boolean-logic esegue logica booleana (AND, OR, NOT)
technique:composition usa la composizione
technique:concurrency esegue codice in modo concorrente
technique:enumeration enumera i valori
technique:error-handling gestisce gli errori
technique:exceptions cattura o lancia eccezioni
technique:function-composition usa la composizione di funzioni
technique:generator usa un generatore
technique:higher-order-functions usa funzioni di ordine superiore
technique:immutability usa l'immutabilità
technique:immutable-collection usa una collezione i cui contenuti sono immutabili
technique:inheritance usa l'ereditarietà
technique:laziness produce valori in modo pigro, solo quando servono
technique:locks usa i lock per ottenere accesso esclusivo alle risorse
technique:looping usa i cicli
technique:math usa la matematica
technique:memory-management gestisce la memoria
technique:ordering ordina i dati
technique:parallelism esegue codice in parallelo
technique:parser fa il parsing dei dati
technique:pointers usa i puntatori
technique:randomness usa la casualità
technique:recursion usa la ricorsione
technique:regular-expression usa le espressioni regolari
technique:short-circuiting usa la valutazione a corto circuito per evitare calcoli non necessari
technique:sorted-collection usa una collezione i cui elementi sono sempre ordinati
technique:sorting ordina i dati
technique:tail-call-optimization usa l'ottimizzazione delle chiamate in coda per una ricorsione efficiente
technique:type-conversion converte valori da un tipo a un altro
technique:unsafe usa codice unsafe (ad esempio l'aritmetica dei puntatori)

Costrutti

Tag Descrizione
construct:abstract-class definisce una classe astratta
construct:abstract-method definisce un metodo astratto
construct:add-assignment combina l'addizione con l'assegnazione
construct:add usa l'addizione
construct:array usa o dichiara un array
construct:assignment assegna o lega un valore a una variabile/nome
construct:async-await usa async/await
construct:attribute annota un membro con metadati
construct:auto-implemented-property definisce una proprietà auto-implementata
construct:big-integer usa un big integer
construct:binary-number definisce un numero in notazione binaria
construct:bit-array usa o dichiara un bit array
construct:bitwise-and-assignment combina un AND bitwise con l'assegnazione
construct:bitwise-and esegue un AND bitwise
construct:bitwise-left-shift-assignment combina uno shift a sinistra bitwise con l'assegnazione
construct:bitwise-left-shift esegue uno shift a sinistra bitwise
construct:bitwise-not esegue un NOT bitwise
construct:bitwise-or-assignment combina un OR bitwise con l'assegnazione
construct:bitwise-or esegue un OR bitwise
construct:bitwise-right-shift-assignment combina uno shift a destra bitwise con l'assegnazione
construct:bitwise-right-shift esegue uno shift a destra bitwise
construct:bitwise-xor-assignment combina un XOR bitwise con l'assegnazione
construct:bitwise-xor esegue un XOR bitwise
construct:block definisce un blocco che contiene un elenco di istruzioni
construct:boolean definisce o usa un valore booleano
construct:boxing usa il boxing
construct:break interrompe un ciclo
construct:byte usa un intero senza segno a 8 bit
construct:catch cattura un'eccezione
construct:char usa un carattere
construct:checked-arithmetic usa l'aritmetica checked (che protegge dagli overflow)
construct:class definisce una classe
construct:collection-initializer imposta i valori di una collezione tramite un inizializzatore
construct:command definisce un comando
construct:comment definisce un commento
construct:comparison-chaining concatena chiamate di confronto
construct:comparison confronta due valori in base al loro ordine relativo
construct:complex-number usa un numero complesso
construct:computed-string definisce una stringa calcolata
construct:concatenation concatena valori
construct:conditional-access accede a un metodo in modo condizionale
construct:conditional-operator usa un operatore condizionale ternario
construct:conditional esegue codice in modo condizionale
construct:constant definisce un valore costante (immutabile)
construct:constructor definisce un costruttore
construct:continue passa all'iterazione successiva di un ciclo
construct:conversion-operator definisce un operatore di conversione
construct:copy copia un valore
construct:coroutine definisce o usa una coroutine
construct:custom-attribute definisce un attributo personalizzato
construct:date-time usa un valore che rappresenta una combinazione di data e ora
construct:date usa un valore che rappresenta una data (senza ora)
construct:decimal usa un numero in virgola mobile a 128 bit
construct:decrement decrementa un valore
construct:default-interface-implementation definisce un'implementazione predefinita in un'interfaccia
construct:default definisce un valore predefinito (ad es. per un parametro)
construct:destructuring scompone un valore nelle sue parti
construct:dictionary-comprehension crea un dizionario tramite una comprehension
construct:dictionary usa/definisce un dizionario/mappa
construct:discard usa il valore speciale discard
construct:divide-assignment combina la divisione con l'assegnazione
construct:divide usa la divisione
construct:do-while-loop usa un ciclo do-while
construct:double usa un numero in virgola mobile a 64 bit
construct:else definisce un ramo else
construct:enum definisce o usa un enum (enumerazione di valori)
construct:equality confronta l'uguaglianza di due valori
construct:error definisce o usa un errore
construct:event definisce o usa eventi
construct:exception definisce o usa eccezioni
construct:explicit-conversion converte esplicitamente da un tipo a un altro
construct:explicit-import importa solo funzionalità selezionate
construct:exponentiation calcola l'elevamento a potenza di un valore
construct:expression-bodied-member definisce un membro con corpo a espressione
construct:extension-method definisce un metodo di estensione
construct:field-access accede a un campo
construct:field definisce un campo
construct:finally usa finally per assicurarsi che un blocco di codice specifico venga sempre eseguito
construct:flags-enum definisce o usa un enum di flag
construct:float usa un numero in virgola mobile a 32 bit
construct:floating-point-number usa un numero in virgola mobile
construct:for-loop usa un ciclo for
construct:foreach usa un ciclo foreach
construct:function-overloading usa l'overloading delle funzioni
construct:function definisce una funzione
construct:generator definisce una funzione o un metodo generatore
construct:generic-function definisce una funzione parametrizzata con uno o più tipi
construct:generic-method definisce un metodo parametrizzato con uno o più tipi
construct:generic-type definisce un tipo parametrizzato con uno o più tipi
construct:getter definisce un getter
construct:global-function definisce una funzione disponibile a livello globale
construct:global-variable definisce una variabile disponibile a livello globale
construct:header definisce un file header
construct:hexadecimal-number definisce un numero in notazione esadecimale
construct:if usa un'istruzione if
construct:implicit-conversion converte implicitamente da un tipo a un altro
construct:implicit-loop itera implicitamente su una collezione di valori
construct:implicit-return restituisce un valore in modo implicito
construct:import importa funzionalità implementate altrove (ad es. da un namespace/modulo)
construct:increment incrementa un valore
construct:index-operator definisce un operatore per indicizzare un oggetto
construct:indexer definisce o usa un indexer
construct:indexing accede a un valore tramite indice
construct:inequality confronta la disuguaglianza di due valori
construct:infix-operator definisce un operatore infisso
construct:initialization inizializza un oggetto dopo la creazione
construct:initializer-list inizializza i valori dei campi di un oggetto
construct:initializer inizializza un oggetto
construct:instance crea o usa un'istanza di un tipo
construct:instantiation crea un'istanza di un tipo
construct:int usa un intero con segno a 32 bit
construct:integral-number usa un numero intero
construct:interface definisce un'interfaccia
construct:invocation chiama un metodo/una funzione
construct:iterator definisce una funzione o un metodo su cui si può iterare
construct:jagged-array usa un jagged array (un array di array)
construct:lambda definisce una lambda (detta anche «funzione anonima»)
construct:linked-list usa una lista concatenata
construct:linq usa LINQ
construct:list-comprehension costruisce una lista tramite una comprehension
construct:list usa una lista
construct:local-function definisce una funzione locale
construct:local-variable definisce una variabile locale
construct:lock usa un lock
construct:logical-and esegue un AND logico
construct:logical-not esegue un NOT logico
construct:logical-or esegue un OR logico
construct:long usa un intero con segno a 64 bit
construct:loop definisce un ciclo
construct:macro definisce una macro
construct:membership-test verifica se un valore è contenuto in un altro valore
construct:metatable definisce una metatabella
construct:method-chaining concatena diverse chiamate di metodo
construct:method-overloading usa l'overloading dei metodi
construct:method-override definisce un metodo sovrascritto
construct:method definisce un metodo
construct:module definisce un modulo (raggruppamento di codice)
construct:modulo-assignment combina il resto della divisione con l'assegnazione
construct:modulo usa il resto della divisione
construct:multi-dimensional-array usa un array con più dimensioni
construct:multiline-string definisce una stringa multiriga
construct:multiple-assignment assegna più valori contemporaneamente
construct:multiple-dispatch usa il multiple dispatch
construct:multiply-assignment combina la moltiplicazione con l'assegnazione
construct:multiply usa la moltiplicazione
construct:named-argument passa un argomento per nome
construct:namespace definisce un namespace (raggruppamento di codice)
construct:nested-function definisce una funzione annidata
construct:nested-type definisce un tipo annidato
construct:nesting usa l'annidamento
construct:nint usa un intero con segno specifico della piattaforma (a 32 o 64 bit)
construct:nuint usa un intero senza segno specifico della piattaforma (a 32 o 64 bit)
construct:null usa null/nil per rappresentare l'assenza di un valore
construct:nullability gestisce valori null/nil
construct:number usa un numero (con o senza segno)
construct:object-initializer imposta i valori di un oggetto tramite un inizializzatore
construct:octal-number definisce un numero in notazione ottale
construct:operator-overloading usa l'overloading degli operatori
construct:option usa un tipo option
construct:optional-parameter definisce un parametro opzionale
construct:overflow usa l'overflow aritmetico
construct:parameter definisce un parametro
construct:parenthesized-expression racchiude un'espressione tra parentesi
construct:pattern-matching usa il pattern matching
construct:pattern definisce un pattern usato nel pattern matching
construct:pipe-backward usa una pipe all'indietro
construct:pipe-forward usa una pipe in avanti
construct:pipeline definisce una pipeline
construct:point-free definisce funzioni senza gli argomenti su cui operano
construct:pointer usa un puntatore
construct:postfix-decrement decrementa un valore usando la notazione postfissa
construct:postfix-increment incrementa un valore usando la notazione postfissa
construct:prefix-decrement decrementa un valore usando la notazione prefissa
construct:prefix-increment incrementa un valore usando la notazione prefissa
construct:print stampa un valore sulla console
construct:property definisce una proprietà (getter/setter)
construct:query-expression interroga i dati tramite un'espressione
construct:queue usa una coda
construct:range definisce un intervallo
construct:read-only definisce un valore di sola lettura
construct:record definisce un record
construct:regular-expression definisce o usa un'espressione regolare
construct:result usa un tipo result
construct:return-type definisce il tipo restituito da una funzione o un metodo
construct:return esce da una funzione o da un metodo
construct:sbyte usa un intero con segno a 8 bit
construct:scientific-notation-number definisce un numero in notazione scientifica
construct:set-comprehension crea un set tramite una comprehension
construct:set usa un set
construct:setter definisce un setter
construct:short usa un intero con segno a 16 bit
construct:slice usa una slice
construct:stack usa uno stack
construct:static-field definisce un campo statico
construct:static-method definisce un metodo statico
construct:string-formatting costruisce una stringa tramite una stringa di formato
construct:string-interpolation definisce una stringa interpolata
construct:string definisce una stringa
construct:struct definisce una struct
construct:subtract-assignment combina la sottrazione con l'assegnazione
construct:subtract usa la sottrazione
construct:sum-type definisce un tipo somma
construct:switch usa uno switch
construct:table definisce una tabella
construct:template-alias definisce un alias per un template
construct:template-parameter definisce un parametro template
construct:template definisce un template
construct:throw lancia un'eccezione
construct:time usa un oggetto che rappresenta l'ora
construct:try gestisce un'eccezione in modo esplicito
construct:tuple usa una tupla
construct:type-alias definisce un alias per un tipo
construct:type-conversion converte (esegue il cast di) un valore in un altro tipo
construct:type-extension estende un tipo con nuove funzionalità
construct:type-inference deduce automaticamente il tipo di un valore/di una funzione
construct:type-test verifica se un valore ha un tipo specifico
construct:uint usa un intero senza segno a 32 bit
construct:ulong usa un intero senza segno a 64 bit
construct:unary-minus usa un meno unario
construct:unary-plus usa un più unario
construct:underscored-number usa un numero con underscore come separatori delle cifre
construct:union-type definisce un tipo unione
construct:user-defined-exception definisce un'eccezione personalizzata definita dall'utente
construct:ushort usa un intero senza segno a 16 bit
construct:using-directive usa codice da un altro file
construct:using-statement assegna e libera un valore tramite l'istruzione using
construct:varargs definisce un parametro che accetta zero o più valori
construct:variable dichiara una variabile
construct:vector usa un vettore
construct:verbatim-string usa una stringa verbatim (senza sequenze di escape)
construct:virtual-method definisce un metodo virtuale
construct:visibility-modifiers specifica la visibilità di un costrutto (ad es. un metodo o una classe)
construct:while-loop usa un ciclo while
construct:yield restituisce un valore in un ciclo in modo pigro

Uses

Poiché questa categoria è specifica del linguaggio, qui non ci sono tag di uso comune.