Megoldások címkézése

Az elemzőcímkék segítségével azonosítható, hogy hogyan született meg egy megoldás.

Ezek a címkék ezután a következőkre használhatók:

  • megoldás összekapcsolása megközelítésekkel
  • megoldás összekapcsolása fogalmakkal
  • megoldások keresése bizonyos címkék alapján

Formátum

Egy címke egy olyan string, amelynek formátuma: <category>:<thing>.

Négy különböző kategóriát támogatunk, a legmagasabb szinttől a legalacsonyabbig:

Kategória Leírás Specifikusság Példák
paradigm Egy programozási paradigma Nagyon magas szintű, nem kurzusspecifikus imperative, functional
technique Egy használt technika Magas szintű, a többségük nem kurzusspecifikus recursion, immutability
construct Egy nyelvi konstrukció Sok közülük nem kurzusspecifikus bitwise-and, for-loop
uses Nyelvspecifikus használat, például típusok vagy metódusok Alacsony szintű, kurzusspecifikus DateTime.add_seconds, IEnumerable

Néhány példacímke:

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

Gyakran használt címkék

Bár a kurzusok szabadon címkézhetik a megoldásokat, ahogy jónak látják, azt javasoljuk, hogy lehetőség szerint próbáld használni az alábbi, gyakran használt címkék listáját. A közös címkekészlet használatával néhány ügyes dolgot tehetünk lehetővé, például a megoldások kurzusközi összekapcsolását.

Paradigma

Címke Leírás
paradigm:array tömbprogramozást használ.
paradigm:declarative deklaratív programozást használ.
paradigm:functional funkcionális programozást használ.
paradigm:generic generikus programozást használ.
paradigm:imperative imperatív programozást használ.
paradigm:logic logikai programozást használ.
paradigm:meta metaprogramozást használ.
paradigm:object-oriented objektumorientált programozást használ.
paradigm:procedural procedurális programozást használ.
paradigm:reflective reflektív programozást használ.
paradigm:stack-oriented veremorientált programozást használ.

Technikák

Címke Leírás
technique:bit-manipulation biteket manipulál, általában bitenkénti operátorokkal (pl. AND, XOR vagy left shift)
technique:bit-shifting biteket tol el egy számban
technique:boolean-logic Boolean logikát hajt végre (AND, OR, NOT)
technique:composition kompozíciót használ
technique:concurrency egyidejűleg futtat kódot
technique:enumeration értékeken iterál
technique:error-handling hibákat kezel
technique:exceptions kivételeket kap el vagy dob
technique:function-composition függvénykompozíciót használ
technique:generator generátort használ
technique:higher-order-functions magasabb rendű függvényeket használ
technique:immutability változhatatlanságot használ
technique:immutable-collection olyan kollekciót használ, amelynek tartalma változhatatlan
technique:inheritance öröklést használ
technique:laziness lazán állít elő értékeket, csak amikor szükség van rájuk
technique:locks zárakat használ az erőforrásokhoz való kizárólagos hozzáféréshez
technique:looping ciklusokat használ
technique:math matematikát használ
technique:memory-management memóriát kezel
technique:ordering adatokat sorrendbe állít
technique:parallelism kódot futtat párhuzamosan
technique:parser adatokat értelmez
technique:pointers mutatókat használ
technique:randomness véletlenszerűséget használ
technique:recursion rekurziót használ
technique:regular-expression reguláris kifejezéseket használ
technique:short-circuiting rövidre zárást használ a felesleges kiértékelés elkerülésére
technique:sorted-collection olyan kollekciót használ, amelynek elemei mindig rendezettek
technique:sorting adatokat rendez
technique:tail-call-optimization farokhívás-optimalizálást használ a hatékony rekurzióhoz
technique:type-conversion értékeket alakít át egyik típusból a másikba
technique:unsafe nem biztonságos kódot használ (például mutatóaritmetikát)

Konstrukciók

Címke Leírás
construct:abstract-class absztrakt osztályt definiál
construct:abstract-method absztrakt metódust definiál
construct:add-assignment összevonja az összeadást az értékadással
construct:add összeadást használ
construct:array tömböt használ vagy deklarál
construct:assignment értéket rendel vagy köt egy változóhoz/névhez
construct:async-await async/await-et használ
construct:attribute metaadatokkal lát el egy tagot
construct:auto-implemented-property automatikusan megvalósított tulajdonságot definiál
construct:big-integer nagy egész számot használ
construct:binary-number számot definiál bináris jelöléssel
construct:bit-array bittömböt használ vagy deklarál
construct:bitwise-and-assignment összevonja a bitenkénti AND-et az értékadással
construct:bitwise-and bitenkénti AND-et hajt végre
construct:bitwise-left-shift-assignment összevonja a bitenkénti balra tolást az értékadással
construct:bitwise-left-shift bitenkénti balra tolást hajt végre
construct:bitwise-not bitenkénti NOT-ot hajt végre
construct:bitwise-or-assignment összevonja a bitenkénti OR-t az értékadással
construct:bitwise-or bitenkénti OR-t hajt végre
construct:bitwise-right-shift-assignment összevonja a bitenkénti jobbra tolást az értékadással
construct:bitwise-right-shift bitenkénti jobbra tolást hajt végre
construct:bitwise-xor-assignment összevonja a bitenkénti XOR-t az értékadással
construct:bitwise-xor bitenkénti XOR-t hajt végre
construct:block utasítások listáját tartalmazó blokkot definiál
construct:boolean Boolean értéket definiál vagy használ
construct:boxing boxingot használ
construct:break kilép egy ciklusból
construct:byte előjel nélküli 8 bites egész számot használ
construct:catch kivételt kap el
construct:char karaktert használ
construct:checked-arithmetic ellenőrzött aritmetikát használ (amely véd a túlcsordulás ellen)
construct:class osztályt definiál
construct:collection-initializer kezdőértéken keresztül állítja be egy kollekció értékeit
construct:command parancsot definiál
construct:comment megjegyzést definiál
construct:comparison-chaining összehasonlító hívásokat fűz össze
construct:comparison két értéket hasonlít össze egymáshoz viszonyított sorrendjük alapján
construct:complex-number komplex számot használ
construct:computed-string számított stringet definiál
construct:concatenation értékeket fűz össze
construct:conditional-access feltételesen ér el egy metódust
construct:conditional-operator ternáris feltételes operátort használ
construct:conditional feltételesen hajt végre kódot
construct:constant konstans (változhatatlan) értéket definiál
construct:constructor konstruktort definiál
construct:continue továbblép a ciklus következő iterációjára
construct:conversion-operator konverziós operátort definiál
construct:copy értéket másol
construct:coroutine korutint definiál vagy használ
construct:custom-attribute egyéni attribútumot definiál
construct:date-time dátumot és időt együtt reprezentáló értéket használ
construct:date dátumot reprezentáló értéket használ (idő nélkül)
construct:decimal 128 bites lebegőpontos számot használ
construct:decrement csökkent egy értéket
construct:default-interface-implementation alapértelmezett implementációt definiál egy interfészben
construct:default alapértelmezett értéket definiál (pl. egy paraméterhez)
construct:destructuring egy értéket bont szét a részeire
construct:dictionary-comprehension szótárt hoz létre egy comprehension segítségével
construct:dictionary szótárt/map-et használ vagy definiál
construct:discard a speciális discard értéket használ
construct:divide-assignment összevonja az osztást az értékadással
construct:divide osztást használ
construct:do-while-loop do-while ciklust használ
construct:double 64 bites lebegőpontos számot használ
construct:else else ágat definiál
construct:enum enumot (értékek felsorolását) definiál vagy használ
construct:equality két érték egyenlőségét hasonlítja össze
construct:error hibát definiál vagy használ
construct:event eseményeket definiál vagy használ
construct:exception kivételeket definiál vagy használ
construct:explicit-conversion explicit módon alakít át egyik típusból a másikba
construct:explicit-import csak kiválasztott funkciókat importál
construct:exponentiation kiszámítja egy érték hatványozását
construct:expression-bodied-member kifejezéstestű tagot definiál
construct:extension-method kiterjesztési metódust definiál
construct:field-access elér egy mezőt
construct:field mezőt definiál
construct:finally a finally segítségével biztosítja, hogy egy adott kódblokk mindig lefusson
construct:flags-enum flag enumot definiál vagy használ
construct:float 32 bites lebegőpontos számot használ
construct:floating-point-number lebegőpontos számot használ
construct:for-loop for ciklust használ
construct:foreach foreach ciklust használ
construct:function-overloading függvénytúlterhelést használ
construct:function függvényt definiál
construct:generator generátor függvényt vagy metódust definiál
construct:generic-function egy vagy több típussal paraméterezett függvényt definiál
construct:generic-method egy vagy több típussal paraméterezett metódust definiál
construct:generic-type egy vagy több típussal paraméterezett típust definiál
construct:getter gettert definiál
construct:global-function globálisan elérhető függvényt definiál
construct:global-variable globálisan elérhető változót definiál
construct:header header fájlt definiál
construct:hexadecimal-number számot definiál hexadecimális jelöléssel
construct:if if utasítást használ
construct:implicit-conversion implicit módon alakít át egyik típusból a másikba
construct:implicit-loop implicit módon iterál egy értékekből álló kollekción
construct:implicit-return implicit módon ad vissza egy értéket
construct:import máshol megvalósított funkciókat importál (pl. egy névtérből/modulból)
construct:increment növel egy értéket
construct:index-operator operátort definiál egy objektum indexeléséhez
construct:indexer indexelőt definiál vagy használ
construct:indexing index alapján ér el egy értéket
construct:inequality két érték egyenlőtlenségét hasonlítja össze
construct:infix-operator infix operátort definiál
construct:initialization létrehozás után inicializál egy objektumot
construct:initializer-list inicializálja egy objektum mezőinek értékeit
construct:initializer inicializál egy objektumot
construct:instance létrehozza vagy használja egy típus egy példányát
construct:instantiation létrehozza egy típus egy példányát
construct:int előjeles 32 bites egész számot használ
construct:integral-number egész számot használ
construct:interface interfészt definiál
construct:invocation meghív egy metódust/függvényt
construct:iterator olyan függvényt vagy metódust definiál, amelyen végig lehet iterálni
construct:jagged-array szaggatott tömböt használ (tömbök tömbjét)
construct:lambda lambdát definiál (más néven „névtelen függvényt”)
construct:linked-list láncolt listát használ
construct:linq LINQ-t használ
construct:list-comprehension listát épít egy comprehension segítségével
construct:list listát használ
construct:local-function lokális függvényt definiál
construct:local-variable lokális változót definiál
construct:lock zárat használ
construct:logical-and logikai AND-et hajt végre
construct:logical-not logikai NOT-ot hajt végre
construct:logical-or logikai OR-t hajt végre
construct:long előjeles 64 bites egész számot használ
construct:loop ciklust definiál
construct:macro makrót definiál
construct:membership-test teszteli, hogy egy érték tagja-e egy másik értéknek
construct:metatable metatáblát definiál
construct:method-chaining több metódushívást fűz össze
construct:method-overloading metódustúlterhelést használ
construct:method-override felülírt metódust definiál
construct:method metódust definiál
construct:module modult definiál (kód csoportosítása)
construct:modulo-assignment összevonja az osztási maradékot az értékadással
construct:modulo osztási maradékot használ
construct:multi-dimensional-array többdimenziós tömböt használ
construct:multiline-string többsoros stringet definiál
construct:multiple-assignment egyszerre több értéket rendel hozzá
construct:multiple-dispatch többszörös dispatch-et használ
construct:multiply-assignment összevonja a szorzást az értékadással
construct:multiply szorzást használ
construct:named-argument névre hivatkozva ad át egy argumentumot
construct:namespace névteret definiál (kód csoportosítása)
construct:nested-function egymásba ágyazott függvényt definiál
construct:nested-type egymásba ágyazott típust definiál
construct:nesting egymásba ágyazást használ
construct:nint előjeles, platformspecifikus egész számot használ (32 vagy 64 bites)
construct:nuint előjel nélküli, platformspecifikus egész számot használ (32 vagy 64 bites)
construct:null null/nil-t használ egy érték hiányának reprezentálására
construct:nullability null/nil értékekkel foglalkozik
construct:number számot használ (előjeles vagy előjel nélküli)
construct:object-initializer kezdőértéken keresztül állítja be egy objektum értékeit
construct:octal-number számot definiál oktális jelöléssel
construct:operator-overloading operátortúlterhelést használ
construct:option option típust használ
construct:optional-parameter opcionális paramétert definiál
construct:overflow aritmetikai túlcsordulást használ
construct:parameter paramétert definiál
construct:parenthesized-expression zárójelbe tesz egy kifejezést
construct:pattern-matching mintaillesztést használ
construct:pattern mintát definiál a mintaillesztéshez
construct:pipe-backward hátrafelé irányuló pipe-ot használ
construct:pipe-forward előrefelé irányuló pipe-ot használ
construct:pipeline pipeline-t definiál
construct:point-free függvényeket definiál azon argumentumok nélkül, amelyeken működnek
construct:pointer mutatót használ
construct:postfix-decrement postfix jelöléssel csökkent egy értéket
construct:postfix-increment postfix jelöléssel növel egy értéket
construct:prefix-decrement prefix jelöléssel csökkent egy értéket
construct:prefix-increment prefix jelöléssel növel egy értéket
construct:print kiír egy értéket a konzolra
construct:property tulajdonságot definiál (getter/setter)
construct:query-expression kifejezésen keresztül kérdez le adatokat
construct:queue sort használ
construct:range tartományt definiál
construct:read-only csak olvasható értéket definiál
construct:record recordot definiál
construct:regular-expression reguláris kifejezést definiál vagy használ
construct:result result típust használ
construct:return-type definiálja egy függvény vagy metódus visszatérési típusát
construct:return visszatér egy függvényből/metódusból
construct:sbyte előjeles 8 bites egész számot használ
construct:scientific-notation-number számot definiál tudományos jelöléssel
construct:set-comprehension halmazt hoz létre egy comprehension segítségével
construct:set halmazt használ
construct:setter settert definiál
construct:short előjeles 16 bites egész számot használ
construct:slice szeletet használ
construct:stack vermet használ
construct:static-field statikus mezőt definiál
construct:static-method statikus metódust definiál
construct:string-formatting formátumstring segítségével épít fel egy stringet
construct:string-interpolation interpolált stringet definiál
construct:string stringet definiál
construct:struct structot definiál
construct:subtract-assignment összevonja a kivonást az értékadással
construct:subtract kivonást használ
construct:sum-type összegtípust definiál
construct:switch switch-et használ
construct:table táblázatot definiál
construct:template-alias álnevet definiál egy templatehez
construct:template-parameter template paramétert definiál
construct:template templateet definiál
construct:throw kivételt dob
construct:time az időt reprezentáló objektumot használ
construct:try explicit módon kezel egy kivételt
construct:tuple tuple-t használ
construct:type-alias álnevet definiál egy típushoz
construct:type-conversion átalakít (castol) egy értéket egy másik típusra
construct:type-extension kiterjeszt egy típust új funkciókkal
construct:type-inference automatikusan kikövetkezteti egy érték/függvény típusát
construct:type-test teszteli, hogy egy érték egy adott típusú-e
construct:uint előjel nélküli 32 bites egész számot használ
construct:ulong előjel nélküli 64 bites egész számot használ
construct:unary-minus unáris mínuszt használ
construct:unary-plus unáris pluszt használ
construct:underscored-number olyan számot használ, amelyben alulvonások választják el a számjegyeket
construct:union-type uniótípust definiál
construct:user-defined-exception egyéni, felhasználó által definiált kivételt definiál
construct:ushort előjel nélküli 16 bites egész számot használ
construct:using-directive másik fájlból származó kódot használ
construct:using-statement a using utasításon keresztül hozzárendel és felszabadít egy értéket
construct:varargs olyan paramétert definiál, amely nulla vagy több érték átadását támogatja
construct:variable változót deklarál
construct:vector vektort használ
construct:verbatim-string verbatim stringet használ (escape-szekvenciák nélkül)
construct:virtual-method virtuális metódust definiál
construct:visibility-modifiers meghatározza egy konstrukció (pl. egy metódus vagy osztály) láthatóságát
construct:while-loop while ciklust használ
construct:yield lazán ad át egy értéket egy ciklusban

Használat

Mivel ez a kategória nyelvspecifikus, itt nincsenek gyakran használt címkék.