Etiquetado de soluciones

Las etiquetas del analizador se usan para identificar cómo se ha resuelto una solución.

Estas etiquetas se pueden usar después para:

  • Vincular una solución con enfoques
  • Vincular una solución con conceptos
  • Buscar soluciones con ciertas etiquetas

Formato

Una etiqueta es un string que tiene el formato: <category>:<thing>.

Admitimos cuatro categorías distintas, de mayor a menor nivel:

Categoría Descripción Especificidad Ejemplos
paradigm Un paradigma de programación De muy alto nivel, no específico del track imperative, functional
technique Una técnica que se usa De alto nivel; la mayoría no será específica del track recursion, immutability
construct Una construcción del lenguaje Muchas no serán específicas del track bitwise-and, for-loop
uses Uso específico del lenguaje, como tipos o métodos De bajo nivel, específico del track DateTime.add_seconds, IEnumerable

Algunos ejemplos de etiquetas:

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

Etiquetas de uso común

Aunque cada track es libre de etiquetar las soluciones como quiera, recomendamos intentar usar la siguiente lista de etiquetas de uso común siempre que sea posible. Usar un conjunto común de etiquetas nos permitirá hacer algunas cosas interesantes, como enlazar soluciones entre distintos tracks.

Paradigma

Etiqueta Descripción
paradigm:array usa la programación con arrays.
paradigm:declarative usa la programación declarativa.
paradigm:functional usa la programación funcional.
paradigm:generic usa la programación genérica.
paradigm:imperative usa la programación imperativa.
paradigm:logic usa la programación lógica.
paradigm:meta usa la metaprogramación.
paradigm:object-oriented usa la programación orientada a objetos.
paradigm:procedural usa la programación por procedimientos.
paradigm:reflective usa la programación reflexiva.
paradigm:stack-oriented usa la programación orientada a la pila.

Técnicas

Etiqueta Descripción
technique:bit-manipulation manipula bits, normalmente mediante operadores bit a bit (p. ej., AND, XOR o desplazamiento a la izquierda)
technique:bit-shifting desplaza bits en un número
technique:boolean-logic ejecuta lógica booleana (AND, OR, NOT)
technique:composition usa composición
technique:concurrency ejecuta código de forma concurrente
technique:enumeration enumera valores
technique:error-handling gestiona errores
technique:exceptions captura o lanza excepciones
technique:function-composition usa composición de funciones
technique:generator usa un generador
technique:higher-order-functions usa funciones de orden superior
technique:immutability usa inmutabilidad
technique:immutable-collection usa una colección cuyo contenido es inmutable
technique:inheritance usa herencia
technique:laziness produce valores de forma perezosa, solo cuando se necesitan
technique:locks usa bloqueos para obtener acceso exclusivo a recursos
technique:looping usa bucles
technique:math usa matemáticas
technique:memory-management gestiona la memoria
technique:ordering ordena datos
technique:parallelism ejecuta código en paralelo
technique:parser procesa datos
technique:pointers usa punteros
technique:randomness usa aleatoriedad
technique:recursion usa recursividad
technique:regular-expression usa expresiones regulares
technique:short-circuiting usa la evaluación de cortocircuito para evitar evaluaciones innecesarias
technique:sorted-collection usa una colección cuyos elementos siempre están ordenados
technique:sorting clasifica datos
technique:tail-call-optimization usa la optimización de llamadas de cola para una recursión eficiente
technique:type-conversion convierte valores de un tipo a otro
technique:unsafe usa código inseguro (por ejemplo, aritmética de punteros)

Construcciones

Etiqueta Descripción
construct:abstract-class define una clase abstracta
construct:abstract-method define un método abstracto
construct:add-assignment combina la suma con la asignación
construct:add usa la suma
construct:array usa o declara un array
construct:assignment asigna o vincula un valor a una variable o nombre
construct:async-await usa async/await
construct:attribute anota un miembro con metadatos
construct:auto-implemented-property define una propiedad autoimplementada
construct:big-integer usa un entero grande
construct:binary-number define un número en notación binaria
construct:bit-array usa o declara un array de bits
construct:bitwise-and-assignment combina un AND bit a bit con la asignación
construct:bitwise-and ejecuta un AND bit a bit
construct:bitwise-left-shift-assignment combina un desplazamiento a la izquierda bit a bit con la asignación
construct:bitwise-left-shift ejecuta un desplazamiento a la izquierda bit a bit
construct:bitwise-not ejecuta un NOT bit a bit
construct:bitwise-or-assignment combina un OR bit a bit con la asignación
construct:bitwise-or ejecuta un OR bit a bit
construct:bitwise-right-shift-assignment combina un desplazamiento a la derecha bit a bit con la asignación
construct:bitwise-right-shift ejecuta un desplazamiento a la derecha bit a bit
construct:bitwise-xor-assignment combina un XOR bit a bit con la asignación
construct:bitwise-xor ejecuta un XOR bit a bit
construct:block define un bloque que contiene una lista de instrucciones
construct:boolean define o usa un valor booleano
construct:boxing usa boxing
construct:break sale de un bucle
construct:byte usa un entero sin signo de 8 bits
construct:catch captura una excepción
construct:char usa un carácter
construct:checked-arithmetic usa aritmética comprobada (que protege frente a desbordamientos)
construct:class define una clase
construct:collection-initializer establece los valores de una colección mediante un inicializador
construct:command define un comando
construct:comment define un comentario
construct:comparison-chaining encadena llamadas de comparación
construct:comparison compara dos valores por su orden relativo
construct:complex-number usa un número complejo
construct:computed-string define un string calculado
construct:concatenation concatena valores
construct:conditional-access accede a un método de forma condicional
construct:conditional-operator usa un operador condicional ternario
construct:conditional ejecuta código de forma condicional
construct:constant define un valor constante (inmutable)
construct:constructor define un constructor
construct:continue continúa con la siguiente iteración de un bucle
construct:conversion-operator define un operador de conversión
construct:copy copia un valor
construct:coroutine define o usa una corrutina
construct:custom-attribute define un atributo personalizado
construct:date-time usa un valor que representa una combinación de fecha y hora
construct:date usa un valor que representa una fecha (sin hora)
construct:decimal usa un número de coma flotante de 128 bits
construct:decrement decrementa un valor
construct:default-interface-implementation define una implementación predeterminada en una interfaz
construct:default define un valor predeterminado (p. ej., para un parámetro)
construct:destructuring desestructura un valor en sus partes
construct:dictionary-comprehension crea un diccionario mediante una comprensión
construct:dictionary usa o define un diccionario o mapa
construct:discard usa el valor especial de descarte
construct:divide-assignment combina la división con la asignación
construct:divide usa la división
construct:do-while-loop usa un bucle do-while
construct:double usa un número de coma flotante de 64 bits
construct:else define una rama else
construct:enum define o usa un enum (enumeración de valores)
construct:equality compara la igualdad de dos valores
construct:error define o usa un error
construct:event define o usa eventos
construct:exception define o usa excepciones
construct:explicit-conversion convierte de un tipo a otro de forma explícita
construct:explicit-import importa solo una funcionalidad concreta
construct:exponentiation calcula la potenciación de un valor
construct:expression-bodied-member define un miembro con cuerpo de expresión
construct:extension-method define un método de extensión
construct:field-access accede a un campo
construct:field define un campo
construct:finally usa finally para asegurar que un bloque de código concreto siempre se ejecute
construct:flags-enum define o usa un enum de indicadores
construct:float usa un número de coma flotante de 32 bits
construct:floating-point-number usa un número de coma flotante
construct:for-loop usa un bucle for
construct:foreach usa un bucle foreach
construct:function-overloading usa sobrecarga de funciones
construct:function define una función
construct:generator define una función o método generador
construct:generic-function define una función parametrizada con uno o más tipos
construct:generic-method define un método parametrizado con uno o más tipos
construct:generic-type define un tipo parametrizado con uno o más tipos
construct:getter define un getter
construct:global-function define una función disponible de forma global
construct:global-variable define una variable disponible de forma global
construct:header define un fichero de cabecera
construct:hexadecimal-number define un número en notación hexadecimal
construct:if usa una instrucción if
construct:implicit-conversion convierte de un tipo a otro de forma implícita
construct:implicit-loop recorre implícitamente una colección de valores
construct:implicit-return devuelve un valor de forma implícita
construct:import importa funcionalidad implementada en otro lugar (p. ej., desde un espacio de nombres o módulo)
construct:increment incrementa un valor
construct:index-operator define un operador para indexar un objeto
construct:indexer define o usa un indexador
construct:indexing accede a un valor por su índice
construct:inequality compara la desigualdad de dos valores
construct:infix-operator define un operador infijo
construct:initialization inicializa un objeto después de crearlo
construct:initializer-list inicializa los valores de los campos de un objeto
construct:initializer inicializa un objeto
construct:instance crea o usa una instancia de un tipo
construct:instantiation crea una instancia de un tipo
construct:int usa un entero con signo de 32 bits
construct:integral-number usa un número entero
construct:interface define una interfaz
construct:invocation invoca un método o función
construct:iterator define una función o método sobre el que se puede iterar
construct:jagged-array usa un array irregular (un array de arrays)
construct:lambda define una lambda (también llamada «función anónima»)
construct:linked-list usa una lista enlazada
construct:linq usa LINQ
construct:list-comprehension construye una lista mediante una comprensión
construct:list usa una lista
construct:local-function define una función local
construct:local-variable define una variable local
construct:lock usa un bloqueo
construct:logical-and ejecuta un AND lógico
construct:logical-not ejecuta un NOT lógico
construct:logical-or ejecuta un OR lógico
construct:long usa un entero con signo de 64 bits
construct:loop define un bucle
construct:macro define una macro
construct:membership-test comprueba si un valor pertenece a otro valor
construct:metatable define una metatabla
construct:method-chaining encadena varias llamadas a métodos
construct:method-overloading usa sobrecarga de métodos
construct:method-override define un método sobrescrito
construct:method define un método
construct:module define un módulo (agrupación de código)
construct:modulo-assignment combina el residuo de la división con la asignación
construct:modulo usa el residuo de la división
construct:multi-dimensional-array usa un array con varias dimensiones
construct:multiline-string define un string multilínea
construct:multiple-assignment asigna varios valores a la vez
construct:multiple-dispatch usa despacho múltiple
construct:multiply-assignment combina la multiplicación con la asignación
construct:multiply usa la multiplicación
construct:named-argument pasa un argumento por nombre
construct:namespace define un espacio de nombres (agrupación de código)
construct:nested-function define una función anidada
construct:nested-type define un tipo anidado
construct:nesting usa anidamiento
construct:nint usa un entero con signo específico de la plataforma (de 32 o 64 bits)
construct:nuint usa un entero sin signo específico de la plataforma (de 32 o 64 bits)
construct:null usa null o nil para representar la ausencia de un valor
construct:nullability trata con valores null o nil
construct:number usa un número (con o sin signo)
construct:object-initializer establece los valores de un objeto mediante un inicializador
construct:octal-number define un número en notación octal
construct:operator-overloading usa sobrecarga de operadores
construct:option usa un tipo opcional
construct:optional-parameter define un parámetro opcional
construct:overflow usa desbordamiento aritmético
construct:parameter define un parámetro
construct:parenthesized-expression encierra una expresión entre paréntesis
construct:pattern-matching usa coincidencia de patrones
construct:pattern define un patrón usado en la coincidencia de patrones
construct:pipe-backward usa una tubería hacia atrás
construct:pipe-forward usa una tubería hacia delante
construct:pipeline define un pipeline
construct:point-free define funciones sin los argumentos sobre los que operan
construct:pointer usa un puntero
construct:postfix-decrement decrementa un valor usando notación postfija
construct:postfix-increment incrementa un valor usando notación postfija
construct:prefix-decrement decrementa un valor usando notación prefija
construct:prefix-increment incrementa un valor usando notación prefija
construct:print imprime un valor en la consola
construct:property define una propiedad (getter/setter)
construct:query-expression consulta datos mediante una expresión
construct:queue usa una cola
construct:range define un rango
construct:read-only define un valor de solo lectura
construct:record define un registro
construct:regular-expression define o usa una expresión regular
construct:result usa un tipo de resultado
construct:return-type define el tipo devuelto de una función o método
construct:return devuelve desde una función o método
construct:sbyte usa un entero con signo de 8 bits
construct:scientific-notation-number define un número en notación científica
construct:set-comprehension crea un conjunto mediante una comprensión
construct:set usa un conjunto
construct:setter define un setter
construct:short usa un entero con signo de 16 bits
construct:slice usa un slice
construct:stack usa una pila
construct:static-field define un campo estático
construct:static-method define un método estático
construct:string-formatting construye un string mediante una cadena de formato
construct:string-interpolation define un string interpolado
construct:string define un string
construct:struct define un struct
construct:subtract-assignment combina la resta con la asignación
construct:subtract usa la resta
construct:sum-type define un tipo suma
construct:switch usa un switch
construct:table define una tabla
construct:template-alias define un alias para una plantilla
construct:template-parameter define un parámetro de plantilla
construct:template define una plantilla
construct:throw lanza una excepción
construct:time usa un objeto que representa la hora
construct:try gestiona una excepción de forma explícita
construct:tuple usa una tupla
construct:type-alias define un alias para un tipo
construct:type-conversion convierte (con un cast) un valor a otro tipo
construct:type-extension extiende un tipo con nueva funcionalidad
construct:type-inference infiere automáticamente el tipo de un valor o función
construct:type-test comprueba si un valor tiene un tipo concreto
construct:uint usa un entero sin signo de 32 bits
construct:ulong usa un entero sin signo de 64 bits
construct:unary-minus usa un menos unario
construct:unary-plus usa un más unario
construct:underscored-number usa un número con guiones bajos como separadores de dígitos
construct:union-type define un tipo unión
construct:user-defined-exception define una excepción personalizada definida por el usuario
construct:ushort usa un entero sin signo de 16 bits
construct:using-directive usa código de otro fichero
construct:using-statement asigna y libera un valor mediante la instrucción using
construct:varargs define un parámetro que admite pasar cero o más valores
construct:variable declara una variable
construct:vector usa un vector
construct:verbatim-string usa un string textual (sin secuencias de escape)
construct:virtual-method define un método virtual
construct:visibility-modifiers especifica la visibilidad de una construcción (p. ej., un método o una clase)
construct:while-loop usa un bucle while
construct:yield produce un valor de forma perezosa en un bucle

Usos

Como esta categoría es específica de cada lenguaje, aquí no hay etiquetas de uso común.