From 306ab1d4bff7298302767c1c0895c49363b1b80b Mon Sep 17 00:00:00 2001 From: apurvabanka Date: Sun, 27 Oct 2024 01:38:23 -0400 Subject: [PATCH 1/2] Kotlin implementation for Lists --- web/thesauruses/kotlin/1.5/lists.json | 228 ++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 web/thesauruses/kotlin/1.5/lists.json diff --git a/web/thesauruses/kotlin/1.5/lists.json b/web/thesauruses/kotlin/1.5/lists.json new file mode 100644 index 000000000..3005c8cb9 --- /dev/null +++ b/web/thesauruses/kotlin/1.5/lists.json @@ -0,0 +1,228 @@ +{ + "meta": { + "language": "kotlin", + "language_version": "1.5", + "language_name": "Kotlin", + "structure": "lists" + }, + "concepts": { + "name_of_ordered_mutable_list": { + "comment": "In Kotlin, the ordered mutable list is called `MutableList`, which is a dynamically sized array.", + "code": "MutableList", + "name": "What is a ordered mutable list called?" + }, + "create_a_ordered_mutable_list": { + "comment": "Kotlin MutableLists are generic and provide mutable collections. To create a MutableList, use the `mutableListOf` function with the desired type.", + "code": "val myList: MutableList = mutableListOf()", + "name": "Create the list" + }, + "ordered_mutable_list_start_number": { + "comment": "The starting index of ordered lists in Kotlin is 0, following standard array indexing.", + "code": "0", + "name": "What number does it start at?" + }, + "access_element_in_ordered_mutable_list": { + "comment": "Accessing elements by index is an O(1) operation in Kotlin's ArrayList-backed MutableList.", + "code": "myList[1]", + "name": "Access element by index" + }, + "insert_into_beginning_of_ordered_mutable_list": { + "comment": "Inserts an element at the beginning of the MutableList, shifting other elements to the right.", + "code": "myList.add(0, 7)", + "name": "Insert element at beginning" + }, + "insert_into_end_of_ordered_mutable_list": { + "comment": "Inserts an element at the end of the MutableList.", + "code": "myList.add(10)", + "name": "Insert element at end" + }, + "insert_into_middle_of_ordered_mutable_list": { + "comment": "Inserts an element at the specified index, shifting other elements as needed.", + "code": "myList.add(1, 7)", + "name": "Insert element in middle" + }, + "erase_element_at_beginning_of_ordered_mutable_list": { + "comment": "Removes the first element of the MutableList, shifting remaining elements to the left.", + "code": "myList.removeAt(0)", + "name": "Erase first element" + }, + "erase_element_at_end_of_ordered_mutable_list": { + "comment": "Removes the last element in the MutableList by index.", + "code": "myList.removeAt(myList.size - 1)", + "name": "Erase last element" + }, + "erase_element_in_middle_of_ordered_mutable_list": { + "comment": "Removes an element at the specified index in the middle of the list.", + "code": "myList.removeAt(1)", + "name": "Erase element in the middle" + }, + "swap_elements_in_ordered_mutable_list": { + "comment": "Swaps two elements in the MutableList at the specified indices, using `Collections.swap`.", + "code": "Collections.swap(myList, index1, index2)", + "name": "Swap two elements" + }, + "delete_ordered_mutable_list": { + "comment": "Clears all elements in the MutableList. Assigning null is only possible if the list variable is nullable.", + "code": "myList.clear()", + "name": "Delete the list" + }, + "name_of_unordered_mutable_list": { + "comment": "In Kotlin, the closest equivalent to an unordered mutable list is a `MutableSet`, which is an unordered collection of unique elements.", + "code": "MutableSet", + "name": "What is a unordered mutable list called?" + }, + "create_a_unordered_mutable_list": { + "comment": "Creates a MutableSet using the `mutableSetOf` function with the desired type.", + "code": "val mySet: MutableSet = mutableSetOf()", + "name": "Create the list" + }, + "unordered_mutable_list_start_number": { + "comment": "Kotlin sets do not maintain an order, so there is no starting index.", + "code": "N/A", + "name": "What number does it start at?" + }, + "access_element_in_unordered_mutable_list": { + "comment": "Accessing elements by index is not supported in Kotlin's `Set`. Use `contains` to check for the presence of elements.", + "code": "mySet.contains(1)", + "name": "Access element by index" + }, + "insert_into_unordered_mutable_list": { + "comment": "Inserts an element into the MutableSet. If the element already exists, it is not added again.", + "code": "mySet.add(7)", + "name": "Insert element in middle" + }, + "erase_element_at_beginning_of_unordered_mutable_list": { + "comment": "Removes a specific element from the set, not index-based.", + "code": "mySet.remove(0)", + "name": "Erase first element" + }, + "erase_element_at_end_of_unordered_mutable_list": { + "comment": "Removes the last element, but this concept does not apply as sets are unordered.", + "code": "mySet.remove(mySet.last())", + "name": "Erase last element" + }, + "erase_element_in_middle_of_unordered_mutable_list": { + "comment": "Removes a specific element from the set; exact middle index is not applicable.", + "code": "mySet.remove(7)", + "name": "Erase element in the middle" + }, + "swap_elements_in_unordered_mutable_list": { + "not-implemented": true, + "comment": "Swapping elements is not applicable in an unordered MutableSet.", + "name": "Swap two elements" + }, + "delete_unordered_mutable_list": { + "comment": "Clears all elements in the MutableSet.", + "code": "mySet.clear()", + "name": "Delete the list" + }, + "name_of_ordered_immutable_list": { + "comment": "In Kotlin, `List` is an immutable ordered list by default.", + "code": "List", + "name": "What is a ordered immutable list called?" + }, + "create_a_ordered_immutable_list": { + "comment": "Creates an immutable List using the `listOf` function with specified elements.", + "code": "val myList: List = listOf(1, 2, 3)", + "name": "Create the list" + }, + "ordered_immutable_list_start_number": { + "comment": "Immutable ordered lists in Kotlin also start indexing at 0.", + "code": "0", + "name": "What number does it start at?" + }, + "access_element_in_ordered_immutable_list": { + "comment": "Access elements by index in an immutable list using square brackets.", + "code": "myList[1]", + "name": "Access element by index" + }, + "delete_ordered_immutable_list": { + "not-implemented": true, + "comment": "Kotlin does not allow deletion of elements from immutable lists. Use a MutableList if deletions are needed.", + "name": "Delete the list" + }, + "name_of_unordered_immutable_list": { + "comment": "Kotlin's `Set` is immutable by default when created using `setOf`.", + "code": "Set", + "name": "What is a unordered immutable list called?" + }, + "create_a_unordered_immutable_list": { + "comment": "Creates an immutable Set with unique elements using `setOf`.", + "code": "val mySet: Set = setOf(1, 2, 3)", + "name": "Create the list" + }, + "unordered_immutable_list_start_number": { + "not-implemented": true, + "comment": "No concept of start number in unordered lists.", + "name": "What number does it start at?" + }, + "access_element_in_unordered_immutable_list": { + "not-implemented": true, + "comment": "Unordered sets do not support index-based access.", + "name": "Access element by index" + }, + "delete_unordered_immutable_list": { + "not-implemented": true, + "comment": "Immutable sets cannot be modified.", + "name": "Delete the list" + }, + "name_of_mutable_hashed_list": { + "comment": "Kotlin offers `LinkedHashMap` for mutable key-value storage with ordered keys, or `HashMap` for unordered keys.", + "code": "LinkedHashMap", + "name": "What is a mutable hashed list called?" + }, + "create_a_mutable_hashed_list": { + "comment": "Creates a mutable LinkedHashMap with key-value pairs.", + "code": "val myNumbers = linkedMapOf()", + "name": "Create the list" + }, + "insert_element_to_mutable_hashed_list": { + "comment": "Inserts a key-value pair into the map, updating the value if the key already exists.", + "code": "myNumbers[5] = \"Five\"", + "name": "Insert element at beginning" + }, + "delete_mutable_hashed_list": { + "comment": "Removes all elements from the mutable map.", + "code": "myNumbers.clear()", + "name": "Delete the list" + }, + "access_element_by_key_in_mutable_hashed_list": { + "comment": "Accesses the value associated with the key, or null if it does not exist.", + "code": "myNumbers[1]", + "name": "Access element by key" + }, + "get_all_keys_from_immutable_set": { + "code": "frozenTranslations.keys", + "name": "Get all keys" + }, + "get_all_values_from_immutable_set": { + "code": "frozenTranslations.values", + "name": "Get all values" + }, + "delete_immutable_set": { + "not-implemented": true, + "name": "Delete the set" + }, + "name_of_ordered_list_by_insertion": { + "comment": "Kotlin provides `LinkedHashMap` and `LinkedHashSet` for maintaining insertion order.", + "code": "LinkedHashMap", + "name": "Name of list ordered by insertion" + }, + "create_ordered_list_by_insertion": { + "code": "val orderedMap = linkedMapOf()", + "name": "Create ordered list by insertion" + }, + "sort_list": { + "code": "val sortedList = myList.sorted()", + "name": "Sort a list" + }, + "filter_list": { + "code": "val evenNumbers = myList.filter { it % 2 == 0 }", + "name": "Filter a list" + }, + "reduce_list": { + "code": "val sum = myList.reduce { acc, num -> acc + num }", + "name": "Reduce a list left-to-right" + } + } +} From e5c9c471768b03218482354cef2daa849e0ac39d Mon Sep 17 00:00:00 2001 From: apurvabanka Date: Sun, 27 Oct 2024 01:52:01 -0400 Subject: [PATCH 2/2] updating list --- web/thesauruses/kotlin/1.5/lists.json | 249 ++++++++++++++++---------- 1 file changed, 155 insertions(+), 94 deletions(-) diff --git a/web/thesauruses/kotlin/1.5/lists.json b/web/thesauruses/kotlin/1.5/lists.json index 3005c8cb9..378dedaf1 100644 --- a/web/thesauruses/kotlin/1.5/lists.json +++ b/web/thesauruses/kotlin/1.5/lists.json @@ -7,222 +7,283 @@ }, "concepts": { "name_of_ordered_mutable_list": { - "comment": "In Kotlin, the ordered mutable list is called `MutableList`, which is a dynamically sized array.", + "comment": "Provided by `MutableList` in Kotlin.", "code": "MutableList", "name": "What is a ordered mutable list called?" }, "create_a_ordered_mutable_list": { - "comment": "Kotlin MutableLists are generic and provide mutable collections. To create a MutableList, use the `mutableListOf` function with the desired type.", + "comment": "Kotlin's MutableList supports generics.", "code": "val myList: MutableList = mutableListOf()", "name": "Create the list" }, "ordered_mutable_list_start_number": { - "comment": "The starting index of ordered lists in Kotlin is 0, following standard array indexing.", "code": "0", "name": "What number does it start at?" }, "access_element_in_ordered_mutable_list": { - "comment": "Accessing elements by index is an O(1) operation in Kotlin's ArrayList-backed MutableList.", + "comment": "Indexed access is efficient in a MutableList.", "code": "myList[1]", "name": "Access element by index" }, "insert_into_beginning_of_ordered_mutable_list": { - "comment": "Inserts an element at the beginning of the MutableList, shifting other elements to the right.", "code": "myList.add(0, 7)", "name": "Insert element at beginning" }, "insert_into_end_of_ordered_mutable_list": { - "comment": "Inserts an element at the end of the MutableList.", "code": "myList.add(10)", "name": "Insert element at end" }, "insert_into_middle_of_ordered_mutable_list": { - "comment": "Inserts an element at the specified index, shifting other elements as needed.", + "comment": "Inserts element at index 1.", "code": "myList.add(1, 7)", "name": "Insert element in middle" }, "erase_element_at_beginning_of_ordered_mutable_list": { - "comment": "Removes the first element of the MutableList, shifting remaining elements to the left.", "code": "myList.removeAt(0)", "name": "Erase first element" }, "erase_element_at_end_of_ordered_mutable_list": { - "comment": "Removes the last element in the MutableList by index.", "code": "myList.removeAt(myList.size - 1)", "name": "Erase last element" }, "erase_element_in_middle_of_ordered_mutable_list": { - "comment": "Removes an element at the specified index in the middle of the list.", + "comment": "Removes element at index 1.", "code": "myList.removeAt(1)", "name": "Erase element in the middle" }, "swap_elements_in_ordered_mutable_list": { - "comment": "Swaps two elements in the MutableList at the specified indices, using `Collections.swap`.", "code": "Collections.swap(myList, index1, index2)", "name": "Swap two elements" }, "delete_ordered_mutable_list": { - "comment": "Clears all elements in the MutableList. Assigning null is only possible if the list variable is nullable.", - "code": "myList.clear()", + "comment": "Setting list to null for garbage collection eligibility.", + "code": "myList = null", "name": "Delete the list" }, "name_of_unordered_mutable_list": { - "comment": "In Kotlin, the closest equivalent to an unordered mutable list is a `MutableSet`, which is an unordered collection of unique elements.", - "code": "MutableSet", - "name": "What is a unordered mutable list called?" + "code": "HashSet", + "name": "What is an unordered mutable list called?" }, "create_a_unordered_mutable_list": { - "comment": "Creates a MutableSet using the `mutableSetOf` function with the desired type.", "code": "val mySet: MutableSet = mutableSetOf()", - "name": "Create the list" + "name": "Create the unordered mutable list" }, "unordered_mutable_list_start_number": { - "comment": "Kotlin sets do not maintain an order, so there is no starting index.", - "code": "N/A", + "code": "Unordered lists don’t have indices in Kotlin", "name": "What number does it start at?" }, "access_element_in_unordered_mutable_list": { - "comment": "Accessing elements by index is not supported in Kotlin's `Set`. Use `contains` to check for the presence of elements.", - "code": "mySet.contains(1)", - "name": "Access element by index" + "code": "mySet.contains(element)", + "name": "Access element by value" }, "insert_into_unordered_mutable_list": { - "comment": "Inserts an element into the MutableSet. If the element already exists, it is not added again.", - "code": "mySet.add(7)", - "name": "Insert element in middle" + "code": "mySet.add(element)", + "name": "Insert element in unordered list" }, "erase_element_at_beginning_of_unordered_mutable_list": { - "comment": "Removes a specific element from the set, not index-based.", - "code": "mySet.remove(0)", - "name": "Erase first element" + "comment": "No 'beginning' in unordered lists.", + "code": "mySet.remove(mySet.first())", + "name": "Erase element (no specific order)" }, "erase_element_at_end_of_unordered_mutable_list": { - "comment": "Removes the last element, but this concept does not apply as sets are unordered.", + "comment": "No 'end' in unordered lists.", "code": "mySet.remove(mySet.last())", - "name": "Erase last element" + "name": "Erase element (no specific order)" }, "erase_element_in_middle_of_unordered_mutable_list": { - "comment": "Removes a specific element from the set; exact middle index is not applicable.", - "code": "mySet.remove(7)", - "name": "Erase element in the middle" + "comment": "Unordered lists don't support indexed access.", + "code": "mySet.remove(element)", + "name": "Erase element (no specific order)" }, "swap_elements_in_unordered_mutable_list": { "not-implemented": true, - "comment": "Swapping elements is not applicable in an unordered MutableSet.", "name": "Swap two elements" }, "delete_unordered_mutable_list": { - "comment": "Clears all elements in the MutableSet.", - "code": "mySet.clear()", - "name": "Delete the list" + "comment": "Setting set to null for garbage collection eligibility.", + "code": "mySet = null", + "name": "Delete the unordered list" }, "name_of_ordered_immutable_list": { - "comment": "In Kotlin, `List` is an immutable ordered list by default.", + "comment": "Kotlin has immutable lists using List interface.", "code": "List", - "name": "What is a ordered immutable list called?" + "name": "What is an ordered immutable list called?" }, "create_a_ordered_immutable_list": { - "comment": "Creates an immutable List using the `listOf` function with specified elements.", - "code": "val myList: List = listOf(1, 2, 3)", - "name": "Create the list" + "code": "val immutableList = listOf(1, 2, 3)", + "name": "Create the ordered immutable list" }, "ordered_immutable_list_start_number": { - "comment": "Immutable ordered lists in Kotlin also start indexing at 0.", "code": "0", "name": "What number does it start at?" }, "access_element_in_ordered_immutable_list": { - "comment": "Access elements by index in an immutable list using square brackets.", - "code": "myList[1]", + "code": "immutableList[0]", "name": "Access element by index" }, "delete_ordered_immutable_list": { - "not-implemented": true, - "comment": "Kotlin does not allow deletion of elements from immutable lists. Use a MutableList if deletions are needed.", - "name": "Delete the list" + "comment": "Setting list to null for garbage collection eligibility.", + "code": "immutableList = null", + "name": "Delete the immutable list" }, "name_of_unordered_immutable_list": { - "comment": "Kotlin's `Set` is immutable by default when created using `setOf`.", "code": "Set", - "name": "What is a unordered immutable list called?" + "name": "What is an unordered immutable list called?" }, "create_a_unordered_immutable_list": { - "comment": "Creates an immutable Set with unique elements using `setOf`.", - "code": "val mySet: Set = setOf(1, 2, 3)", - "name": "Create the list" + "code": "val immutableSet = setOf(1, 2, 3)", + "name": "Create the unordered immutable list" }, "unordered_immutable_list_start_number": { - "not-implemented": true, - "comment": "No concept of start number in unordered lists.", + "code": "No specific order", "name": "What number does it start at?" }, "access_element_in_unordered_immutable_list": { - "not-implemented": true, - "comment": "Unordered sets do not support index-based access.", - "name": "Access element by index" + "code": "immutableSet.contains(element)", + "name": "Access element by value" }, "delete_unordered_immutable_list": { - "not-implemented": true, - "comment": "Immutable sets cannot be modified.", - "name": "Delete the list" + "comment": "Setting set to null for garbage collection eligibility.", + "code": "immutableSet = null", + "name": "Delete the unordered immutable list" }, "name_of_mutable_hashed_list": { - "comment": "Kotlin offers `LinkedHashMap` for mutable key-value storage with ordered keys, or `HashMap` for unordered keys.", - "code": "LinkedHashMap", + "comment": "A `LinkedHashSet` provides set semantics while preserving insertion order.", + "code": "LinkedHashSet", "name": "What is a mutable hashed list called?" }, "create_a_mutable_hashed_list": { - "comment": "Creates a mutable LinkedHashMap with key-value pairs.", - "code": "val myNumbers = linkedMapOf()", + "code": "val myNumbers: LinkedHashMap = linkedMapOf()", "name": "Create the list" }, "insert_element_to_mutable_hashed_list": { - "comment": "Inserts a key-value pair into the map, updating the value if the key already exists.", - "code": "myNumbers[5] = \"Five\"", - "name": "Insert element at beginning" + "code": "myNumbers[1] = \"One\"", + "name": "Insert an element" + }, + "erase_element_from_mutable_hashed_list": { + "code": "myNumbers.remove(1)", + "name": "Erase an element from the list" }, "delete_mutable_hashed_list": { - "comment": "Removes all elements from the mutable map.", - "code": "myNumbers.clear()", + "comment": "Setting map to null for garbage collection eligibility.", + "code": "myNumbers = null", "name": "Delete the list" }, - "access_element_by_key_in_mutable_hashed_list": { - "comment": "Accesses the value associated with the key, or null if it does not exist.", - "code": "myNumbers[1]", - "name": "Access element by key" + "name_of_immutable_hashed_list": { + "comment": "Use a map without mutation functions.", + "code": "Map", + "name": "What is an immutable hashed list called?" + }, + "create_a_immutable_hashed_list": { + "code": "val myImmutableNumbers: Map = mapOf(1 to \"One\", 2 to \"Two\")", + "name": "Create the immutable hashed list" }, - "get_all_keys_from_immutable_set": { - "code": "frozenTranslations.keys", + "delete_immutable_hashed_list": { + "comment": "Setting map to null for garbage collection eligibility.", + "code": "myImmutableNumbers = null", + "name": "Delete the immutable hashed list" + }, + "create_a_mutable_set": { + "code": "val translations: MutableMap = mutableMapOf()", + "name": "Create a mutable key/value set" + }, + "get_key_from_mutable_set": { + "comment": "Key retrieval not by value in maps.", + "not-implemented": true, + "name": "Get key" + }, + "get_value_from_mutable_set": { + "code": "translations[\"coding\"]", + "name": "Get value" + }, + "get_all_keys_from_mutable_set": { + "code": "translations.keys", "name": "Get all keys" }, - "get_all_values_from_immutable_set": { - "code": "frozenTranslations.values", + "get_all_values_from_mutable_set": { + "code": "translations.values", "name": "Get all values" }, - "delete_immutable_set": { + "swap_key_and_value_in_mutable_set": { + "comment": "Swapping keys and values not supported directly.", "not-implemented": true, + "name": "Swap a key and value" + }, + "delete_mutable_set": { + "comment": "Setting map to null for garbage collection eligibility.", + "code": "translations = null", "name": "Delete the set" }, - "name_of_ordered_list_by_insertion": { - "comment": "Kotlin provides `LinkedHashMap` and `LinkedHashSet` for maintaining insertion order.", - "code": "LinkedHashMap", - "name": "Name of list ordered by insertion" + "find_element_by_position": { + "comment": "Finding element by position depends on context.", + "not-implemented": true, + "name": "Find/search for an element by position" + }, + "find_element_by_value": { + "comment": "Finds the first matching element by value.", + "code": "myList.find { it == value }", + "name": "Find/search for an element by value" + }, + "find_minimum_element": { + "code": "myList.minOrNull() ?: throw NoSuchElementException()", + "name": "Find the minimum value in a list" + }, + "find_maximum_element": { + "code": "myList.maxOrNull() ?: throw NoSuchElementException()", + "name": "Find the maximum value in a list" }, - "create_ordered_list_by_insertion": { - "code": "val orderedMap = linkedMapOf()", - "name": "Create ordered list by insertion" + "convert_list_to_string": { + "comment": "Converts list elements to a string representation.", + "code": "myList.joinToString(\", \")", + "name": "Convert a list to a string" + }, + "concatenate_two_lists": { + "code": "val merged = list1 + list2", + "name": "Concatenate two lists together" + }, + "split_list_at_index": { + "code": "val (firstPart, secondPart) = myList.partition { myList.indexOf(it) < index }", + "name": "Split lists at an index" + }, + "duplicate_a_list": { + "code": "val duplicateList = myList.toList()", + "name": "Duplicate a list" + }, + "duplicate_subset_of_list": { + "code": "val duplicateList = myList.subList(2, 5).toList()", + "name": "Duplicate a portion/subset of a list" + }, + "get_list_length": { + "code": "myList.size", + "name": "Get list length" + }, + "do_two_lists_match_exactly": { + "comment": "Checks for deep equality between two lists.", + "code": "list1 == list2", + "name": "Do two lists match every element?" }, "sort_list": { - "code": "val sortedList = myList.sorted()", + "comment": "Sorts list elements in ascending order.", + "code": "myList.sort()", "name": "Sort a list" }, - "filter_list": { - "code": "val evenNumbers = myList.filter { it % 2 == 0 }", - "name": "Filter a list" + "reverse_list": { + "code": "myList.reverse()", + "name": "Reverse order of list elements" + }, + "filter": { + "comment": "Filters list to elements matching a condition.", + "code": "val filteredList = myList.filter { it > 10 }", + "name": "Filter a list based on criteria" + }, + "map": { + "not-implemented": true, + "name": "Map a function onto each element in a list" }, - "reduce_list": { - "code": "val sum = myList.reduce { acc, num -> acc + num }", + "reduce_left": { + "comment": "Example to sum elements in list from left to right.", + "code": "val computedSum = myList.reduce { acc, i -> acc + i }", "name": "Reduce a list left-to-right" } } -} +} \ No newline at end of file