clearing

Author: islamumarov

Backtracking/Class1.cs

@@ -7,6 +7,7 @@
 
         <IsPackable>false</IsPackable>
         <IsTestProject>true</IsTestProject>
+        <OutputType>Library</OutputType>
     </PropertyGroup>
 
     <ItemGroup>

DailyLeetCode.Test/DailyLeetCode.Test.csproj

@@ -0,0 +1,19 @@
+namespace DailyLeetCode.Test;
+
+public class FindRightInterval436Tests
+{
+    [Fact]
+    
+    public void FindRightInterval_AllShouldPass()
+    {
+        var intervals = new int[3][];
+        intervals[0] = new int[]{1,4};
+        intervals[1] = new int[]{2,3};
+        intervals[2] = new int[]{3,4};
+        
+        var actual = FindRightInterval436.FindRightInterval(intervals);
+        var expected = new int[]{-1, 2,-1};
+        
+        Assert.Equal(expected, actual);
+    }
+}

DailyLeetCode.Test/FindRightInterval436Tests.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DailyLeetCode.Test;
+
+public class LengthOfLongestFibonacciSubsequenceTest
+{
+    [Theory]
+    [InlineData(new[] { 1, 2, 3, 4, 5, 6, 7, 8 }, 5)]
+    [InlineData(new[] { 2, 4, 7, 8, 9, 10, 14, 15, 18, 23, 32, 50 }, 5)]
+    public void AllShouldPass_LenLongestFibSubseq(int[] arr, int expected)
+    {
+        var actual = LengthOfLongestFibonacciSubsequence.LenLongestFibSubseq(arr);
+
+        Assert.Equal(expected, actual);
+    }
+}

DailyLeetCode.Test/LengthOfLongestFibonacciSubsequenceTest.cs

@@ -0,0 +1,15 @@
+namespace DailyLeetCode.Test;
+
+public class MaximumOrderedTripletTests
+{
+    [Theory]
+    //[InlineData(new int[]{12,6,1,2,7}, 77)]
+   // [InlineData(new int[]{2,3,1}, 0)]
+    [InlineData(new int[]{1000000,1,1000000}, 999999000000)]
+    public void AllShouldPass_MaximumTripletValue(int[] nums, long expected)
+    {
+        var actual = MaximumOrderedTriplet.MaximumTripletValue_MaxQueue(nums);
+        
+        Assert.Equal(expected, actual);
+    }
+}

DailyLeetCode.Test/MaximumOrderedTripletTests.cs

@@ -0,0 +1,13 @@
+namespace DailyLeetCode.Test;
+
+public class NumberOfSubsContainAllTreeCharsTests
+{
+    
+    [Theory]
+    [InlineData("abcabc", 10)]
+    public void NumberOfSubstrings_AllShouldPass(string s, int expected)
+    {
+        var actual = NumberOfSubsContainAllTreeChars.NumberOfSubstrings(s);
+        Assert.Equal(expected, actual);
+    }
+}

DailyLeetCode.Test/NumberOfSubsContainAllTreeCharsTests.cs

@@ -0,0 +1,14 @@
+namespace DailyLeetCode.Test;
+
+public class OneStringSwapTest
+{
+
+    [Theory]
+    [InlineData("bank", "kanb", true)]
+    [InlineData("aa", "ac", false)]
+    public void AreAlmostEqual_AllShouldPass(string a, string b, bool expected)
+    {
+        var actual = OneStringSwap.AreAlmostEqual(a, b);
+        Assert.Equal(expected, actual);
+    }
+}

DailyLeetCode.Test/OneStringSwapTest.cs

@@ -0,0 +1,38 @@
+namespace DailyLeetCode;
+
+public class FindRightInterval436
+{
+    public static int[] FindRightInterval(int[][] intervals) {
+        
+        Array.Sort(intervals, (a, b) => a[0].CompareTo(b[0]));
+        var ans = new int[intervals.Length];
+        Array.Fill(ans, -1);
+        for (int i = 0; i < intervals.Length; i++)
+        {
+            var left = 0;
+            var right = intervals.Length - 1;
+            var mid = left + (right - left) / 2;
+            if(intervals[i][1] < intervals[mid][1])
+            {
+                while (intervals[i][1] > intervals[mid][1] && mid > 0)
+                {
+                    left = mid + 1;
+                    mid = left + (right - left) / 2;
+                }
+                
+            }
+            else
+            {
+                while (intervals[i][1] < intervals[mid][1] && mid > 0)
+                {
+                    right = mid - 1;
+                    mid = left + (right - left) / 2;
+                }
+            }
+            
+            ans[i] = mid;
+        }
+
+        return ans;
+    }
+}

DailyLeetCode/FindRightInterval.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DailyLeetCode;
+
+public class LengthOfLongestFibonacciSubsequence
+{
+    public static int LenLongestFibSubseq(int[] arr)
+    {
+        int longest = 0;
+        HashSet<int> sum = new HashSet<int>();
+
+        foreach (var a in arr)
+        {
+            sum.Add(a);
+        }
+
+        for (int i = 0; i < arr.Length; i++)
+        {
+            for (int j = i + 1; j < arr.Length; j++)
+            {
+                var prev = arr[j];
+                var curr = arr[i] + arr[j];
+                var currlen = 2;
+
+                while (sum.Contains(curr))
+                {
+                    currlen++;
+                    var tmp = curr;
+                    curr = prev + curr;
+                    prev = tmp;
+                    longest = Math.Max(longest, currlen);
+                }
+            }
+        }
+
+        return longest;
+    }
+}

DailyLeetCode/LengthOfLongestFibonacciSubsequence.cs

@@ -0,0 +1,32 @@
+namespace DailyLeetCode;
+
+public class MaximumOrderedTriplet
+{
+    public static long MaximumTripletValue_MaxQueue(int[] nums)
+    {
+
+        if (nums.Length < 3) return 0;
+        var maxQueue = new PriorityQueue<int[], long>(comparer: Comparer<long>.Create(((i, i1) => (i < i1) ? 1 : -1)));
+
+        for (int i = 0; i < nums.Length; i++)
+        {
+            for (int j = i+1; j < nums.Length; j++)
+            {
+                for (int k = j+1; k < nums.Length; k++)
+                {
+                    long val = (nums[i] - nums[j]) * (long) nums[k];
+                    maxQueue.Enqueue([i,j,k], val);
+                }
+            }
+        }
+        
+        var max = maxQueue.Dequeue();
+        long value = (nums[max[0]] - nums[max[1]]) * (long)nums[max[2]];
+        return value < 0 ? 0 : value;
+    }
+    
+    public static long MaximumTripletValue_PrefixSum(int[] nums)
+    {
+        return 0;
+    }
+}