From c90582048cb1ed03ff79914a25616ff9778cc3cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A1s=20B=20Nagy?= <20251272+BNAndras@users.noreply.github.com> Date: Mon, 3 Aug 2026 08:08:27 -0700 Subject: [PATCH 1/2] Add `binary-search-tree` --- config.json | 8 + exercises/Exercises.slnx | 1 + .../binary-search-tree/.docs/instructions.md | 70 ++++++++ .../practice/binary-search-tree/.editorconfig | 89 ++++++++++ .../binary-search-tree/.meta/Example.vb | 43 +++++ .../binary-search-tree/.meta/config.json | 18 ++ .../binary-search-tree/.meta/tests.toml | 40 +++++ .../binary-search-tree/BinarySearchTree.vb | 17 ++ .../BinarySearchTree.vbproj | 19 ++ .../BinarySearchTreeTests.vb | 127 +++++++++++++ .../binary-search-tree/packages.lock.json | 168 ++++++++++++++++++ 11 files changed, 600 insertions(+) create mode 100644 exercises/practice/binary-search-tree/.docs/instructions.md create mode 100644 exercises/practice/binary-search-tree/.editorconfig create mode 100644 exercises/practice/binary-search-tree/.meta/Example.vb create mode 100644 exercises/practice/binary-search-tree/.meta/config.json create mode 100644 exercises/practice/binary-search-tree/.meta/tests.toml create mode 100644 exercises/practice/binary-search-tree/BinarySearchTree.vb create mode 100644 exercises/practice/binary-search-tree/BinarySearchTree.vbproj create mode 100644 exercises/practice/binary-search-tree/BinarySearchTreeTests.vb create mode 100644 exercises/practice/binary-search-tree/packages.lock.json diff --git a/config.json b/config.json index 64b2d8f8..1210f12c 100644 --- a/config.json +++ b/config.json @@ -117,6 +117,14 @@ ], "difficulty": 2 }, + { + "slug": "binary-search-tree", + "name": "Binary Search Tree", + "uuid": "f3b38287-45f2-4e17-b9a8-70382521f15c", + "practices": [], + "prerequisites": [], + "difficulty": 5 + }, { "slug": "bottle-song", "name": "Bottle Song", diff --git a/exercises/Exercises.slnx b/exercises/Exercises.slnx index 299f9e42..63c4f68b 100644 --- a/exercises/Exercises.slnx +++ b/exercises/Exercises.slnx @@ -11,6 +11,7 @@ + diff --git a/exercises/practice/binary-search-tree/.docs/instructions.md b/exercises/practice/binary-search-tree/.docs/instructions.md new file mode 100644 index 00000000..7625220e --- /dev/null +++ b/exercises/practice/binary-search-tree/.docs/instructions.md @@ -0,0 +1,70 @@ +# Instructions + +Insert and search for numbers in a binary tree. + +When we need to represent sorted data, an array does not make a good data structure. + +Say we have the array `[1, 3, 4, 5]`, and we add 2 to it so it becomes `[1, 3, 4, 5, 2]`. +Now we must sort the entire array again! +We can improve on this by realizing that we only need to make space for the new item `[1, nil, 3, 4, 5]`, and then adding the item in the space we added. +But this still requires us to shift many elements down by one. + +Binary Search Trees, however, can operate on sorted data much more efficiently. + +A binary search tree consists of a series of connected nodes. +Each node contains a piece of data (e.g. the number 3), a variable named `left`, and a variable named `right`. +The `left` and `right` variables point at `nil`, or other nodes. +Since these other nodes in turn have other nodes beneath them, we say that the left and right variables are pointing at subtrees. +All data in the left subtree is less than or equal to the current node's data, and all data in the right subtree is greater than the current node's data. + +For example, if we had a node containing the data 4, and we added the data 2, our tree would look like this: + +![A graph with root node 4 and a single child node 2.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2.svg) + +```text + 4 + / + 2 +``` + +If we then added 6, it would look like this: + +![A graph with root node 4 and two child nodes 2 and 6.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6.svg) + +```text + 4 + / \ + 2 6 +``` + +If we then added 3, it would look like this + +![A graph with root node 4, two child nodes 2 and 6, and a grandchild node 3.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6-3.svg) + +```text + 4 + / \ + 2 6 + \ + 3 +``` + +And if we then added 1, 5, and 7, it would look like this + +![A graph with root node 4, two child nodes 2 and 6, and four grandchild nodes 1, 3, 5 and 7.](https://assets.exercism.org/images/exercises/binary-search-tree/tree-4-2-6-1-3-5-7.svg) + +```text + 4 + / \ + / \ + 2 6 + / \ / \ + 1 3 5 7 +``` + +## Credit + +The images were created by [habere-et-dispertire][habere-et-dispertire] using [PGF/TikZ][pgf-tikz] by Till Tantau. + +[habere-et-dispertire]: https://exercism.org/profiles/habere-et-dispertire +[pgf-tikz]: https://en.wikipedia.org/wiki/PGF/TikZ diff --git a/exercises/practice/binary-search-tree/.editorconfig b/exercises/practice/binary-search-tree/.editorconfig new file mode 100644 index 00000000..11f55d27 --- /dev/null +++ b/exercises/practice/binary-search-tree/.editorconfig @@ -0,0 +1,89 @@ +############################### +# Core EditorConfig Options # +############################### + +; This file is for unifying the coding style for different editors and IDEs. +; More information at: +; https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2022 +; https://docs.microsoft.com/en-us/visualstudio/ide/create-portable-custom-editor-options?view=vs-2022 + +root = true + +[*] +end_of_line = lf +indent_style = space +trim_trailing_whitespace = true +insert_final_newline = true + +[*.{vbproj,slnx}] +indent_size = 2 + +[*.vb] +indent_size = 4 +charset = utf-8 + +############################### +# .NET Coding Conventions # +############################### + +# Organize imports +dotnet_sort_system_directives_first = true +dotnet_separate_import_directive_groups = true + +# Me. preferences +dotnet_style_qualification_for_field = false:suggestion +dotnet_style_qualification_for_property = false:suggestion +dotnet_style_qualification_for_method = false:suggestion +dotnet_style_qualification_for_event = false:suggestion + +# Language keywords vs BCL types preferences +dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion +dotnet_style_predefined_type_for_member_access = true:suggestion + +# Parentheses preferences +dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_other_operators = never_if_unnecessary:suggestion + +# Modifier preferences +dotnet_style_require_accessibility_modifiers = always:suggestion +dotnet_style_readonly_field = true:suggestion + +# Expression-level preferences +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_explicit_tuple_names = true:suggestion +dotnet_style_prefer_inferred_tuple_names = true:suggestion +dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion +dotnet_style_prefer_auto_properties = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion +dotnet_style_prefer_conditional_expression_over_return = true:suggestion +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion + +############################### +# Naming Conventions # +############################### + +# Style Definitions +dotnet_naming_style.pascal_case_style.capitalization = pascal_case + +# Use PascalCase for constant fields +dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols = constant_fields +dotnet_naming_rule.constant_fields_should_be_pascal_case.style = pascal_case_style +dotnet_naming_symbols.constant_fields.applicable_kinds = field +dotnet_naming_symbols.constant_fields.applicable_accessibilities = * +dotnet_naming_symbols.constant_fields.required_modifiers = const + +################################### +# Visual Basic Coding Conventions # +################################### +visual_basic_preferred_modifier_order = Partial, Default, Private, Protected, Public, Friend, NotOverridable, Overridable, MustOverride, Overloads, Overrides, MustInherit, NotInheritable, Static, Shared, Shadows, ReadOnly, WriteOnly, Dim, Const, WithEvents, Widening, Narrowing, Custom, Async:suggestion +visual_basic_style_unused_variable_expression_statement_preference = unused_local_variable:suggestion +visual_basic_style_unused_value_assignment_preference = unused_local_variable:suggestion +visual_basic_style_prefer_isnot_expression = true:suggestion +visual_basic_style_prefer_simplified_object_creation = false:none +dotnet_diagnostic.IDE0090.severity = none diff --git a/exercises/practice/binary-search-tree/.meta/Example.vb b/exercises/practice/binary-search-tree/.meta/Example.vb new file mode 100644 index 00000000..a5366d46 --- /dev/null +++ b/exercises/practice/binary-search-tree/.meta/Example.vb @@ -0,0 +1,43 @@ +Public Class BinarySearchTree(Of T As IComparable(Of T)) + Public Sub New(ByVal data As T) + Me.Data = data + End Sub + + Public ReadOnly Property Data As T + Public Property Left As BinarySearchTree(Of T) + Public Property Right As BinarySearchTree(Of T) + + Public Sub Insert(ByVal value As T) + If value.CompareTo(Data) <= 0 Then + If Left Is Nothing Then + Left = New BinarySearchTree(Of T)(value) + Else + Left.Insert(value) + End If + ElseIf Right Is Nothing Then + Right = New BinarySearchTree(Of T)(value) + Else + Right.Insert(value) + End If + End Sub + + Public Function SortedData() As IEnumerable(Of T) + Dim values As New List(Of T) + + AddSortedData(values) + + Return values + End Function + + Private Sub AddSortedData(ByVal values As List(Of T)) + If Left IsNot Nothing Then + Left.AddSortedData(values) + End If + + values.Add(Data) + + If Right IsNot Nothing Then + Right.AddSortedData(values) + End If + End Sub +End Class diff --git a/exercises/practice/binary-search-tree/.meta/config.json b/exercises/practice/binary-search-tree/.meta/config.json new file mode 100644 index 00000000..8e56a8c9 --- /dev/null +++ b/exercises/practice/binary-search-tree/.meta/config.json @@ -0,0 +1,18 @@ +{ + "authors": [ + "BNAndras" + ], + "files": { + "solution": [ + "BinarySearchTree.vb" + ], + "test": [ + "BinarySearchTreeTests.vb" + ], + "example": [ + ".meta/Example.vb" + ] + }, + "blurb": "Insert and search for numbers in a binary tree.", + "source": "Josh Cheek" +} diff --git a/exercises/practice/binary-search-tree/.meta/tests.toml b/exercises/practice/binary-search-tree/.meta/tests.toml new file mode 100644 index 00000000..c7d32021 --- /dev/null +++ b/exercises/practice/binary-search-tree/.meta/tests.toml @@ -0,0 +1,40 @@ +# This is an auto-generated file. +# +# Regenerating this file via `configlet sync` will: +# - Recreate every `description` key/value pair +# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications +# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion) +# - Preserve any other key/value pair +# +# As user-added comments (using the # character) will be removed when this file +# is regenerated, comments can be added via a `comment` key. + +[e9c93a78-c536-4750-a336-94583d23fafa] +description = "data is retained" + +[7a95c9e8-69f6-476a-b0c4-4170cb3f7c91] +description = "insert data at proper node -> smaller number at left node" + +[22b89499-9805-4703-a159-1a6e434c1585] +description = "insert data at proper node -> same number at left node" + +[2e85fdde-77b1-41ed-b6ac-26ce6b663e34] +description = "insert data at proper node -> greater number at right node" + +[dd898658-40ab-41d0-965e-7f145bf66e0b] +description = "can create complex tree" + +[9e0c06ef-aeca-4202-b8e4-97f1ed057d56] +description = "can sort data -> can sort single number" + +[425e6d07-fceb-4681-a4f4-e46920e380bb] +description = "can sort data -> can sort if second number is smaller than first" + +[bd7532cc-6988-4259-bac8-1d50140079ab] +description = "can sort data -> can sort if second number is same as first" + +[b6d1b3a5-9d79-44fd-9013-c83ca92ddd36] +description = "can sort data -> can sort if second number is greater than first" + +[d00ec9bd-1288-4171-b968-d44d0808c1c8] +description = "can sort data -> can sort complex tree" diff --git a/exercises/practice/binary-search-tree/BinarySearchTree.vb b/exercises/practice/binary-search-tree/BinarySearchTree.vb new file mode 100644 index 00000000..2e21403f --- /dev/null +++ b/exercises/practice/binary-search-tree/BinarySearchTree.vb @@ -0,0 +1,17 @@ +Public Class BinarySearchTree(Of T As IComparable(Of T)) + Public Sub New(ByVal data As T) + Throw New NotImplementedException("You need to implement this function.") + End Sub + + Public ReadOnly Property Data As T + Public Property Left As BinarySearchTree(Of T) + Public Property Right As BinarySearchTree(Of T) + + Public Sub Insert(ByVal value As T) + Throw New NotImplementedException("You need to implement this function.") + End Sub + + Public Function SortedData() As IEnumerable(Of T) + Throw New NotImplementedException("You need to implement this function.") + End Function +End Class diff --git a/exercises/practice/binary-search-tree/BinarySearchTree.vbproj b/exercises/practice/binary-search-tree/BinarySearchTree.vbproj new file mode 100644 index 00000000..b4587f0b --- /dev/null +++ b/exercises/practice/binary-search-tree/BinarySearchTree.vbproj @@ -0,0 +1,19 @@ + + + + net10.0 + Exe + true + + + + + + + + + + + + + diff --git a/exercises/practice/binary-search-tree/BinarySearchTreeTests.vb b/exercises/practice/binary-search-tree/BinarySearchTreeTests.vb new file mode 100644 index 00000000..0ee1ce5c --- /dev/null +++ b/exercises/practice/binary-search-tree/BinarySearchTreeTests.vb @@ -0,0 +1,127 @@ +Public Class BinarySearchTreeTests + + Public Sub Data_Is_Retained() + Dim tree = TreeFrom({4}) + + AssertTree(tree, Node(4)) + End Sub + + + Public Sub Smaller_Number_At_Left_Node() + Dim tree = TreeFrom({4, 2}) + + AssertTree(tree, Node(4, Node(2))) + End Sub + + + Public Sub Same_Number_At_Left_Node() + Dim tree = TreeFrom({4, 4}) + + AssertTree(tree, Node(4, Node(4))) + End Sub + + + Public Sub Greater_Number_At_Right_Node() + Dim tree = TreeFrom({4, 5}) + + AssertTree(tree, Node(4, Nothing, Node(5))) + End Sub + + + Public Sub Can_Create_Complex_Tree() + Dim tree = TreeFrom({4, 2, 6, 1, 3, 5, 7}) + + AssertTree( + tree, + Node( + 4, + Node(2, Node(1), Node(3)), + Node(6, Node(5), Node(7)))) + End Sub + + + Public Sub Can_Sort_Single_Number() + Dim tree = TreeFrom({2}) + Dim expected = {2} + + Assert.Equal(expected, tree.SortedData()) + End Sub + + + Public Sub Can_Sort_If_Second_Number_Is_Smaller_Than_First() + Dim tree = TreeFrom({2, 1}) + Dim expected = {1, 2} + + Assert.Equal(expected, tree.SortedData()) + End Sub + + + Public Sub Can_Sort_If_Second_Number_Is_Same_As_First() + Dim tree = TreeFrom({2, 2}) + Dim expected = {2, 2} + + Assert.Equal(expected, tree.SortedData()) + End Sub + + + Public Sub Can_Sort_If_Second_Number_Is_Greater_Than_First() + Dim tree = TreeFrom({2, 3}) + Dim expected = {2, 3} + + Assert.Equal(expected, tree.SortedData()) + End Sub + + + Public Sub Can_Sort_Complex_Tree() + Dim tree = TreeFrom({2, 1, 3, 6, 7, 5}) + Dim expected = {1, 2, 3, 5, 6, 7} + + Assert.Equal(expected, tree.SortedData()) + End Sub + + Private Shared Function TreeFrom(ByVal values As Integer()) As BinarySearchTree(Of Integer) + Dim tree = New BinarySearchTree(Of Integer)(values(0)) + + For Each value In values.Skip(1) + tree.Insert(value) + Next + + Return tree + End Function + + Private Shared Sub AssertTree(ByVal actual As BinarySearchTree(Of Integer), ByVal expected As ExpectedNode) + If expected Is Nothing Then + Assert.Null(actual) + Return + End If + + Assert.NotNull(actual) + Assert.Equal(expected.Data, actual.Data) + AssertTree(actual.Left, expected.Left) + AssertTree(actual.Right, expected.Right) + End Sub + + Private Shared Function Node( + ByVal data As Integer, + Optional ByVal left As ExpectedNode = Nothing, + Optional ByVal right As ExpectedNode = Nothing) As ExpectedNode + + Return New ExpectedNode(data, left, right) + End Function + + Private Class ExpectedNode + Public Sub New( + ByVal data As Integer, + ByVal left As ExpectedNode, + ByVal right As ExpectedNode) + + Me.Data = data + Me.Left = left + Me.Right = right + End Sub + + Public ReadOnly Property Data As Integer + Public ReadOnly Property Left As ExpectedNode + Public ReadOnly Property Right As ExpectedNode + End Class +End Class diff --git a/exercises/practice/binary-search-tree/packages.lock.json b/exercises/practice/binary-search-tree/packages.lock.json new file mode 100644 index 00000000..8da1f14a --- /dev/null +++ b/exercises/practice/binary-search-tree/packages.lock.json @@ -0,0 +1,168 @@ +{ + "version": 1, + "dependencies": { + "net10.0": { + "Microsoft.NET.Test.Sdk": { + "type": "Direct", + "requested": "[18.3.0, )", + "resolved": "18.3.0", + "contentHash": "xW3kXuWRQtgoxJp4J+gdhHSQyK+6Wb/AZDSd7lMvuMRYlZ1tnpkojyfZlWilB5G4dmZ0Y0ZxU/M23TlubndNkw==", + "dependencies": { + "Microsoft.CodeCoverage": "18.3.0", + "Microsoft.TestPlatform.TestHost": "18.3.0" + } + }, + "xunit.runner.visualstudio": { + "type": "Direct", + "requested": "[3.1.5, )", + "resolved": "3.1.5", + "contentHash": "tKi7dSTwP4m5m9eXPM2Ime4Kn7xNf4x4zT9sdLO/G4hZVnQCRiMTWoSZqI/pYTVeI27oPPqHBKYI/DjJ9GsYgA==" + }, + "xunit.v3": { + "type": "Direct", + "requested": "[3.2.2, )", + "resolved": "3.2.2", + "contentHash": "L+4/4y0Uqcg8/d6hfnxhnwh4j9FaeULvefTwrk30rr1o4n/vdPfyUQ8k0yzH8VJx7bmFEkDdcRfbtbjEHlaYcA==", + "dependencies": { + "xunit.v3.mtp-v1": "[3.2.2]" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.Bcl.AsyncInterfaces": { + "type": "Transitive", + "resolved": "6.0.0", + "contentHash": "UcSjPsst+DfAdJGVDsu346FX0ci0ah+lw3WRtn18NUwEqRt70HaOQ7lI72vy3+1LxtqI3T5GWwV39rQSrCzAeg==" + }, + "Microsoft.CodeCoverage": { + "type": "Transitive", + "resolved": "18.3.0", + "contentHash": "23BNy/vziREC20Wwhb50K7+kZe0m07KlLWDQv4qjJ9tt3QjpDpDIqJFrhYHmMEo9xDkuSp55U/8h4bMF7MiB+g==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "1.9.1", + "contentHash": "No5AudZMmSb+uNXjlgL2y3/stHD2IT4uxqc5yHwkE+/nNux9jbKcaJMvcp9SwgP4DVD8L9/P3OUz8mmmcvEIdQ==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "1.9.1" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "1.9.1", + "contentHash": "AL46Xe1WBi85Ntd4mNPvat5ZSsZ2uejiVqoKCypr8J3wK0elA5xJ3AN4G/Q4GIwzUFnggZoH/DBjnr9J18IO/g==", + "dependencies": { + "Microsoft.Testing.Platform": "1.9.1" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "1.9.1", + "contentHash": "QafNtNSmEI0zazdebnsIkDKmFtTSpmx/5PLOjURWwozcPb3tvRxzosQSL8xwYNM1iPhhKiBksXZyRSE2COisrA==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "1.9.1", + "contentHash": "oTUtyR4X/s9ytuiNA29FGsNCCH0rNmY5Wdm14NCKLjTM1cT9edVSlA+rGS/mVmusPqcP0l/x9qOnMXg16v87RQ==", + "dependencies": { + "Microsoft.Testing.Platform": "1.9.1" + } + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.3.0", + "contentHash": "AEIEX2aWdPO9XbtR96eBaJxmXRD9vaI9uQ1T/JbPEKlTAZwYx0ZrMzKyULMdh/HH9Sg03kXCoN7LszQ90o6nPQ==" + }, + "Microsoft.TestPlatform.TestHost": { + "type": "Transitive", + "resolved": "18.3.0", + "contentHash": "twmsoelXnp1uWMU3VGip9f0Jr1mZ0PZqgJdF35CIrdYgYrkHIJMV1m8uKyhcdjLdsQDESHAgkR7KhS9i1qpJag==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.3.0", + "Newtonsoft.Json": "13.0.3" + } + }, + "Microsoft.Win32.Registry": { + "type": "Transitive", + "resolved": "5.0.0", + "contentHash": "dDoKi0PnDz31yAyETfRntsLArTlVAVzUzCIvvEDsDsucrl33Dl8pIJG06ePTJTI3tGpeyHS9Cq7Foc/s4EeKcg==" + }, + "Newtonsoft.Json": { + "type": "Transitive", + "resolved": "13.0.3", + "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ==" + }, + "xunit.analyzers": { + "type": "Transitive", + "resolved": "1.27.0", + "contentHash": "y/pxIQaLvk/kxAoDkZW9GnHLCEqzwl5TW0vtX3pweyQpjizB9y3DXhb9pkw2dGeUqhLjsxvvJM1k89JowU6z3g==" + }, + "xunit.v3.assert": { + "type": "Transitive", + "resolved": "3.2.2", + "contentHash": "BPciBghgEEaJN/JG00QfCYDfEfnLgQhfnYEy+j1izoeHVNYd5+3Wm8GJ6JgYysOhpBPYGE+sbf75JtrRc7jrdA==" + }, + "xunit.v3.common": { + "type": "Transitive", + "resolved": "3.2.2", + "contentHash": "Hj775PEH6GTbbg0wfKRvG2hNspDCvTH9irXhH4qIWgdrOSV1sQlqPie+DOvFeigsFg2fxSM3ZAaaCDQs+KreFA==", + "dependencies": { + "Microsoft.Bcl.AsyncInterfaces": "6.0.0" + } + }, + "xunit.v3.core.mtp-v1": { + "type": "Transitive", + "resolved": "3.2.2", + "contentHash": "Ga5aA2Ca9ktz+5k3g5ukzwfexwoqwDUpV6z7atSEUvqtd6JuybU1XopHqg1oFd78QdTfZgZE9h5sHpO4qYIi5w==", + "dependencies": { + "Microsoft.Testing.Extensions.Telemetry": "1.9.1", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "1.9.1", + "Microsoft.Testing.Platform": "1.9.1", + "Microsoft.Testing.Platform.MSBuild": "1.9.1", + "xunit.v3.extensibility.core": "[3.2.2]", + "xunit.v3.runner.inproc.console": "[3.2.2]" + } + }, + "xunit.v3.extensibility.core": { + "type": "Transitive", + "resolved": "3.2.2", + "contentHash": "srY8z/oMPvh/t8axtO2DwrHajhFMH7tnqKildvYrVQIfICi8fOn3yIBWkVPAcrKmHMwvXRJ/XsQM3VMR6DOYfQ==", + "dependencies": { + "xunit.v3.common": "[3.2.2]" + } + }, + "xunit.v3.mtp-v1": { + "type": "Transitive", + "resolved": "3.2.2", + "contentHash": "O41aAzYKBT5PWqATa1oEWVNCyEUypFQ4va6K0kz37dduV3EKzXNMaV2UnEhufzU4Cce1I33gg0oldS8tGL5I0A==", + "dependencies": { + "xunit.analyzers": "1.27.0", + "xunit.v3.assert": "[3.2.2]", + "xunit.v3.core.mtp-v1": "[3.2.2]" + } + }, + "xunit.v3.runner.common": { + "type": "Transitive", + "resolved": "3.2.2", + "contentHash": "/hkHkQCzGrugelOAehprm7RIWdsUFVmIVaD6jDH/8DNGCymTlKKPTbGokD5czbAfqfex47mBP0sb0zbHYwrO/g==", + "dependencies": { + "Microsoft.Win32.Registry": "[5.0.0]", + "xunit.v3.common": "[3.2.2]" + } + }, + "xunit.v3.runner.inproc.console": { + "type": "Transitive", + "resolved": "3.2.2", + "contentHash": "ulWOdSvCk+bPXijJZ73bth9NyoOHsAs1ZOvamYbCkD4DNLX/Bd29Ve2ZNUwBbK0MqfIYWXHZViy/HKrdEC/izw==", + "dependencies": { + "xunit.v3.extensibility.core": "[3.2.2]", + "xunit.v3.runner.common": "[3.2.2]" + } + } + } + } +} \ No newline at end of file From 1b2a7bfe5696a9e64cb172bfd8492d8fac21d67a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A1s=20B=20Nagy?= <20251272+BNAndras@users.noreply.github.com> Date: Mon, 3 Aug 2026 08:11:23 -0700 Subject: [PATCH 2/2] Exercise order --- config.json | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/config.json b/config.json index 1210f12c..3d0fc954 100644 --- a/config.json +++ b/config.json @@ -117,14 +117,6 @@ ], "difficulty": 2 }, - { - "slug": "binary-search-tree", - "name": "Binary Search Tree", - "uuid": "f3b38287-45f2-4e17-b9a8-70382521f15c", - "practices": [], - "prerequisites": [], - "difficulty": 5 - }, { "slug": "bottle-song", "name": "Bottle Song", @@ -818,6 +810,14 @@ ], "difficulty": 5 }, + { + "slug": "binary-search-tree", + "name": "Binary Search Tree", + "uuid": "f3b38287-45f2-4e17-b9a8-70382521f15c", + "practices": [], + "prerequisites": [], + "difficulty": 5 + }, { "slug": "bob", "name": "Bob",