C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

var app = builder.Build();

// Configure the HTTP request pipeline.

app.MapPost("/FormatNumberRange", (int[] numbers) =>
{
    if (numbers.Length == 0)
        return Results.BadRequest();

    var tracker = new FormatNumberRangeModel();
    tracker.Low = numbers[0];
    tracker.High = tracker.Low;
    List<string> elements = new List<string>();
    for (int i = 1; i < numbers.Length; i++)
    {
        if (numbers[i] == tracker.High + 1)
        {
            tracker.High = numbers[i];
        }
        else
        {
            if (tracker.Low == tracker.High)
            {
                elements.Add($"{tracker.Low}");
            }
            else
            {
                elements.Add($"{tracker.Low}-{tracker.High}");
            }
            tracker.Low = numbers[i];
            tracker.High = tracker.Low;
        }
    }
    if (tracker.Low == tracker.High)
    {
        elements.Add($"{tracker.Low}");
    }
    else
    {
        elements.Add($"{tracker.Low}-{tracker.High}");
    }

    string result = string.Join(",", elements);
    return Results.Json(result);
});

char[] alphabet = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', };
Dictionary<char, int> alphabetIndex = new Dictionary<char, int>();
for (int i = 0; i < alphabet.Length; i++)
{
    alphabetIndex.Add(alphabet[i], i);
}
app.MapGet("/Excel", (string column) =>
{
    if (column == null || column == "")
        return Results.Json(0);

    int position = 1;
    int result = 0;
    char rightMostChar = column[column.Length - 1];
    result += alphabetIndex[rightMostChar] + 1;
    for (int i = column.Length - 2; i >= 0; i--)
    {
        char c = column[i];
        result += (int)Math.Pow(alphabet.Length, position) * (alphabetIndex[c] + 1);
        position++;
    }
    return Results.Json(result);
});

app.MapPost("/Pagination", (PaginationRequest request) =>
{
    List<int> slice = new List<int>();

    int maxPossiblePageIndex = request.PageSize > 0 ? request.AllRows.Length / request.PageSize : 0;    //fix possible divide by zero
    int pageIndex = Math.Min(request.PageIndex, maxPossiblePageIndex);

    int index = request.PageSize * pageIndex;
    int upperBound = Math.Min(index + request.PageSize, request.AllRows.Length);

    int from = index + 1;
    while (index < upperBound)
    {
        slice.Add(request.AllRows[index]);
        index++;
    }
    PaginationResponse result = new PaginationResponse();
    if (slice.Count > 0)
    {
        result.From = from;
        result.To = upperBound;
    }
    else
    {
        result.From = 0;
        result.To = 0;
    }
    result.Total = request.AllRows.Length;
    result.CurrentPageRows = new int[slice.Count];
    for (int i = 0; i < slice.Count; i++)
    {
        result.CurrentPageRows[i] = slice[i];
    }
    return Results.Json(result);
});

app.MapPost("/MatchingBraces", ([FromBody] string text) =>
{
    bool result = Check();
    return Results.Json(result);

    bool Check()
    {
        Stack<char> stack = new Stack<char>();
        HashSet<char> bracketOpener = new HashSet<char>
        {
            '(',
            '{',
            '[',
        };
        HashSet<char> bracketCloser = new HashSet<char>
        {
            ')',
            '}',
            ']',
        };
        Dictionary<char, char> bracketMatchingPair = new Dictionary<char, char>
        {
            [')'] = '(',
            ['}'] = '{',
            [']'] = '[',
        };
        foreach (char c in text)
        {
            if (bracketOpener.Contains(c))
            {
                stack.Push(c);
            }
            else if (bracketCloser.Contains(c))
            {
                if (!stack.TryPeek(out var opener))     //เจอตัวปิดโดยไม่มีตัวเปิดมาก่อน
                    return false;
                if (bracketMatchingPair[c] != opener)
                    return false;
                stack.Pop();
            }
        }
        return stack.Count == 0;
    }
});

app.MapGet("/URI", (string uri) =>
{
    URIResponse result = ParseURI();
    return Results.Json(result);

    URIResponse ParseURI()
    {
        URIResponse result = new URIResponse();

        string str = uri;

        //Scheme
        int schemeTokenPosition = FindSectionPosition(str, new string[] { "://" });
        if (schemeTokenPosition > 0)
        {
            result.Scheme = str.Substring(0, schemeTokenPosition);
            str = str.Substring(schemeTokenPosition + 3);
        }

        //UserInfo
        int userInfoTokenPosition = FindSectionPosition(str, new string[] { "@" });
        if (userInfoTokenPosition > 0)
        {
            result.UserInfo = str.Substring(0, userInfoTokenPosition);
            str = str.Substring(userInfoTokenPosition + 1);
        }

        //Host, will scan until port or path was found but if none can be found everything remaining is a host
        int portOrPathSeparatorPosition = FindSectionPosition(str, new string[] { ":", "/" });
        if (portOrPathSeparatorPosition > 0)
        {
            result.Host = str.Substring(0, portOrPathSeparatorPosition);
            str = str.Substring(portOrPathSeparatorPosition);
        }
        else
        {
            result.Host = str;
            str = "";
            return result;
        }

        //Port, will scan only if first character is exactly ':' and will scan until port or path was found
        if (str.StartsWith(":"))
        {
            int pathSeparatorPosition = FindSectionPosition(str, new string[] { "/" });
            if (pathSeparatorPosition > 0)
            {
                result.Port = str.Substring(1, pathSeparatorPosition - 1);
                str = str.Substring(pathSeparatorPosition);
            }
        }

        //Path, will scan until query or fragment token was found but if none can be found everything remaining is a path
        int queryOrFragmentTokenPosition = FindSectionPosition(str, new string[] { "?", "#" });
        if (queryOrFragmentTokenPosition > 0)
        {
            result.Path = str.Substring(1, queryOrFragmentTokenPosition - 1);
            str = str.Substring(queryOrFragmentTokenPosition);
        }
        else
        {
            result.Path = str.Substring(1);
            str = "";
            return result;
        }

        //Query, will scan until fragment token was found but if none can be found everything remaining is a query
        int fragmentTokenPosition = FindSectionPosition(str, new string[] { "#" });
        if (fragmentTokenPosition > 0)
        {
            result.Query = str.Substring(0, fragmentTokenPosition);
            str = str.Substring(fragmentTokenPosition);
        }
        else if (fragmentTokenPosition == -1)
        {
            result.Query = str;
            str = "";
            return result;
        }

        result.Fragment = str;
        str = "";
        return result;
    }

    int FindSectionPosition(string source, string[] stopTokens)
    {
        int[] positions = new int[stopTokens.Length];
        for (int i = 0; i < stopTokens.Length; i++)
        {
            positions[i] = source.IndexOf(stopTokens[i], StringComparison.InvariantCulture);
        }

        int minIndex = FindPositiveMinIndex(positions);
        return minIndex >= 0 ? positions[minIndex] : -1;
    }

    int FindPositiveMinIndex(int[] input)
    {
        if (input == null || input.Length == 0)
            return -1;

        int minIndex = -1;
        for (int i = 0; i < input.Length; i++)
        {
            if (input[i] >= 0)
            {
                if (minIndex == -1)
                    minIndex = i;
                else if (input[i] < input[minIndex])
                    minIndex = i;
            }
        }
        return minIndex;
    }
});

app.MapPost("/Directory", (string[] files) =>
{
    DirectoryResponse result = new DirectoryResponse();
    for (int i = 0; i < files.Length; i++)
    {
        FilePathData filePathData = GetFilePathData(files[i]);
        DirectoryResponse parent = result;
        for (int j = 0; j < filePathData.ParentDirectoryLevel.Count; j++)
        {
            int index = FindIndex(parent.SubDirectories, filePathData.ParentDirectoryLevel[j]);
            if (index >= 0)
            {
                parent = parent.SubDirectories[index];
            }
            else
            {
                var dir = new DirectoryResponse();
                dir.Name = filePathData.ParentDirectoryLevel[j];
                parent.SubDirectories.Add(dir);
                parent = dir;
            }
        }
        parent.Files.Add(filePathData.FileName);
    }

    return Results.Json(result);

    FilePathData GetFilePathData(string file)
    {
        FilePathData result = new FilePathData();
        string[] split = file.Split("\\");
        int i = 0;
        for (; i < split.Length - 1; i++)
        {
            result.ParentDirectoryLevel.Add(split[i]);
        }
        result.FileName = split[i];
        return result;
    }

    int FindIndex(List<DirectoryResponse> list, string name)
    {
        for (int i = 0; i < list.Count; i++)
        {
            if (list[i].Name == name)
                return i;
        }
        return -1;
    }
});

app.MapPost("/FindExclusive", (int[][] numbers) =>
{
    int[] left = new int[numbers.Length];
    int[] right = new int[numbers.Length];
    for (int i = 0;i < numbers.Length; i++)
    {
        var element = numbers[i];
        left[i] = element[0];
        right[i] = element[1];
    }
    Dictionary<int, int> rightNumbers = new Dictionary<int, int>();
    for (int i = 0; i < right.Length; i++)
    {
        if (rightNumbers.ContainsKey(right[i]))
        {
            right[i] = right[i] + 1;
        }
        else
        {
            rightNumbers.Add(right[i], 1);
        }
    }
    for (int i = 0; i < left.Length; i++)
    {
        if (rightNumbers.ContainsKey(left[i]))
        {
            rightNumbers.Remove(left[i]);
        }
    }
    int[] result = rightNumbers.Keys.ToArray();
    return Results.Json(result);
});

app.MapPost("/FindCommon", (int[][] numbers) =>
{
    int[] left = new int[numbers.Length];
    int[] right = new int[numbers.Length];
    for (int i = 0; i < numbers.Length; i++)
    {
        var element = numbers[i];
        left[i] = element[0];
        right[i] = element[1];
    }
    Dictionary<int, int> keyReducer = new Dictionary<int, int>();
    for (int i = 0; i < right.Length; i++)
    {
        if (!keyReducer.ContainsKey(right[i]))
        {
            keyReducer.Add(right[i], 0);
        }
    }
    for (int i = 0; i < left.Length; i++)
    {
        if (keyReducer.ContainsKey(left[i]))
        {
            keyReducer[left[i]] = 1;
        }
    }
    int[] keys = keyReducer.Keys.ToArray();
    List<int> intersectionResult = new List<int>();
    for (int i = 0; i < keys.Length; i++)
    {
        int key = keys[i];
        if (keyReducer[key] > 0)
        {
            intersectionResult.Add(key);
        }
    }
    int[] result = new int[intersectionResult.Count];
    for (int i = 0; i < intersectionResult.Count; i++)
    {
        result[i] = intersectionResult[i];
    }
    return Results.Json(result);
});

app.MapPost("/FindAll", (int[][] numbers) =>
{
    int[] left = new int[numbers.Length];
    int[] right = new int[numbers.Length];
    for (int i = 0; i < numbers.Length; i++)
    {
        var element = numbers[i];
        left[i] = element[0];
        right[i] = element[1];
    }
    Dictionary<int, int> keyAccumulator = new Dictionary<int, int>();
    for (int i = 0; i < right.Length; i++)
    {
        if (keyAccumulator.ContainsKey(right[i]))
        {
            right[i] = right[i] + 1;
        }
        else
        {
            keyAccumulator.Add(right[i], 1);
        }
    }
    for (int i = 0; i < left.Length; i++)
    {
        if (keyAccumulator.ContainsKey(left[i]))
        {
            left[i] = left[i] + 1;
        }
        else
        {
            keyAccumulator.Add(left[i], 1);
        }
    }
    int[] result = keyAccumulator.Keys.ToArray();
    return Results.Json(result);
});

app.Run();

class FormatNumberRangeModel
{
    public int Low { get; set; }
    public int High { get; set; }
}

class PaginationRequest
{
    public int[] AllRows { get; set; } = new int[0];
    public int PageIndex { get; set; }
    public int PageSize { get; set; }
}

class PaginationResponse
{
    public int[] CurrentPageRows { get; set; } = new int[0];
    public int From { get; set; }
    public int To { get; set; }
    public int Total { get; set; }
}

class URIResponse
{
    public string Scheme { get; set; } = string.Empty;
    public string UserInfo { get; set; } = string.Empty;
    public string Host { get; set; } = string.Empty;
    public string Port { get; set; } = string.Empty;
    public string Path { get; set; } = string.Empty;
    public string Query { get; set; } = string.Empty;
    public string Fragment { get; set; } = string.Empty;
}

class DirectoryResponse
{
    public string Name { get; set; } = string.Empty;
    public List<DirectoryResponse> SubDirectories { get; set; } = new List<DirectoryResponse>();
    public List<string> Files { get; set; } = new List<string>();
}

class FilePathData
{
    public List<string> ParentDirectoryLevel { get; set; } = new List<string>();
    public string FileName { get; set; } = string.Empty;
}

​x
 
using Microsoft.AspNetCore.Mvc;
​
var builder = WebApplication.CreateBuilder(args);
​
// Add services to the container.
​
var app = builder.Build();
​
// Configure the HTTP request pipeline.
​
app.MapPost("/FormatNumberRange", (int[] numbers) =>
{
    if (numbers.Length == 0)
        return Results.BadRequest();
​
    var tracker = new FormatNumberRangeModel();
    tracker.Low = numbers[0];
    tracker.High = tracker.Low;
    List<string> elements = new List<string>();
    for (int i = 1; i < numbers.Length; i++)
    {
        if (numbers[i] == tracker.High + 1)
        {
            tracker.High = numbers[i];
        }
        else
        {
            if (tracker.Low == tracker.High)
            {
                elements.Add($"{tracker.Low}");
            }
            else
            {
                elements.Add($"{tracker.Low}-{tracker.High}");
            }
            tracker.Low = numbers[i];
            tracker.High = tracker.Low;
        }
    }
    if (tracker.Low == tracker.High)
    {
        elements.Add($"{tracker.Low}");
    }
    else
    {
        elements.Add($"{tracker.Low}-{tracker.High}");
    }
​
    string result = string.Join(",", elements);
    return Results.Json(result);
});
​
char[] alphabet = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', };
Dictionary<char, int> alphabetIndex = new Dictionary<char, int>();
for (int i = 0; i < alphabet.Length; i++)
{
    alphabetIndex.Add(alphabet[i], i);
}
app.MapGet("/Excel", (string column) =>
{
    if (column == null || column == "")
        return Results.Json(0);
​
    int position = 1;
    int result = 0;
    char rightMostChar = column[column.Length - 1];
    result += alphabetIndex[rightMostChar] + 1;
    for (int i = column.Length - 2; i >= 0; i--)
    {
        char c = column[i];
        result += (int)Math.Pow(alphabet.Length, position) * (alphabetIndex[c] + 1);
        position++;
    }
    return Results.Json(result);
});
​
app.MapPost("/Pagination", (PaginationRequest request) =>
{
    List<int> slice = new List<int>();
​
    int maxPossiblePageIndex = request.PageSize > 0 ? request.AllRows.Length / request.PageSize : 0;    //fix possible divide by zero
    int pageIndex = Math.Min(request.PageIndex, maxPossiblePageIndex);
​
    int index = request.PageSize * pageIndex;
    int upperBound = Math.Min(index + request.PageSize, request.AllRows.Length);
​
    int from = index + 1;
    while (index < upperBound)
    {
        slice.Add(request.AllRows[index]);
        index++;
    }
    PaginationResponse result = new PaginationResponse();
    if (slice.Count > 0)
    {
        result.From = from;
        result.To = upperBound;
    }
    else
    {
        result.From = 0;
        result.To = 0;
    }
    result.Total = request.AllRows.Length;
    result.CurrentPageRows = new int[slice.Count];
    for (int i = 0; i < slice.Count; i++)
    {
        result.CurrentPageRows[i] = slice[i];
    }
    return Results.Json(result);
});
​
app.MapPost("/MatchingBraces", ([FromBody] string text) =>
{
    bool result = Check();
    return Results.Json(result);
​
    bool Check()
    {
        Stack<char> stack = new Stack<char>();
        HashSet<char> bracketOpener = new HashSet<char>
        {
            '(',
            '{',
            '[',
        };
        HashSet<char> bracketCloser = new HashSet<char>
        {
            ')',
            '}',
            ']',
        };
        Dictionary<char, char> bracketMatchingPair = new Dictionary<char, char>
        {
            [')'] = '(',
            ['}'] = '{',
            [']'] = '[',
        };
        foreach (char c in text)
        {
            if (bracketOpener.Contains(c))
            {
                stack.Push(c);
            }
            else if (bracketCloser.Contains(c))
            {
                if (!stack.TryPeek(out var opener))     //เจอตัวปิดโดยไม่มีตัวเปิดมาก่อน
                    return false;
                if (bracketMatchingPair[c] != opener)
                    return false;
                stack.Pop();
            }
        }
        return stack.Count == 0;
    }
});
​
app.MapGet("/URI", (string uri) =>
{
    URIResponse result = ParseURI();
    return Results.Json(result);
​
    URIResponse ParseURI()
    {
        URIResponse result = new URIResponse();
​
        string str = uri;
​
        //Scheme
        int schemeTokenPosition = FindSectionPosition(str, new string[] { "://" });
        if (schemeTokenPosition > 0)
        {
            result.Scheme = str.Substring(0, schemeTokenPosition);
            str = str.Substring(schemeTokenPosition + 3);
        }
​
        //UserInfo
        int userInfoTokenPosition = FindSectionPosition(str, new string[] { "@" });
        if (userInfoTokenPosition > 0)
        {
            result.UserInfo = str.Substring(0, userInfoTokenPosition);
            str = str.Substring(userInfoTokenPosition + 1);
        }
​
        //Host, will scan until port or path was found but if none can be found everything remaining is a host
        int portOrPathSeparatorPosition = FindSectionPosition(str, new string[] { ":", "/" });
        if (portOrPathSeparatorPosition > 0)
        {
            result.Host = str.Substring(0, portOrPathSeparatorPosition);
            str = str.Substring(portOrPathSeparatorPosition);
        }
        else
        {
            result.Host = str;
            str = "";
            return result;
        }
​
        //Port, will scan only if first character is exactly ':' and will scan until port or path was found
        if (str.StartsWith(":"))
        {
            int pathSeparatorPosition = FindSectionPosition(str, new string[] { "/" });
            if (pathSeparatorPosition > 0)
            {
                result.Port = str.Substring(1, pathSeparatorPosition - 1);
                str = str.Substring(pathSeparatorPosition);
            }
        }
​
        //Path, will scan until query or fragment token was found but if none can be found everything remaining is a path
        int queryOrFragmentTokenPosition = FindSectionPosition(str, new string[] { "?", "#" });
        if (queryOrFragmentTokenPosition > 0)
        {
            result.Path = str.Substring(1, queryOrFragmentTokenPosition - 1);
            str = str.Substring(queryOrFragmentTokenPosition);
        }
        else
        {
            result.Path = str.Substring(1);
            str = "";
            return result;
        }
​
        //Query, will scan until fragment token was found but if none can be found everything remaining is a query
        int fragmentTokenPosition = FindSectionPosition(str, new string[] { "#" });
        if (fragmentTokenPosition > 0)
        {
            result.Query = str.Substring(0, fragmentTokenPosition);
            str = str.Substring(fragmentTokenPosition);
        }
        else if (fragmentTokenPosition == -1)
        {
            result.Query = str;
            str = "";
            return result;
        }
​
        result.Fragment = str;
        str = "";
        return result;
    }
​
    int FindSectionPosition(string source, string[] stopTokens)
    {
        int[] positions = new int[stopTokens.Length];
        for (int i = 0; i < stopTokens.Length; i++)
        {
            positions[i] = source.IndexOf(stopTokens[i], StringComparison.InvariantCulture);
        }
​
        int minIndex = FindPositiveMinIndex(positions);
        return minIndex >= 0 ? positions[minIndex] : -1;
    }
​
    int FindPositiveMinIndex(int[] input)
    {
        if (input == null || input.Length == 0)
            return -1;
​
        int minIndex = -1;
        for (int i = 0; i < input.Length; i++)
        {
            if (input[i] >= 0)
            {
                if (minIndex == -1)
                    minIndex = i;
                else if (input[i] < input[minIndex])
                    minIndex = i;
            }
        }
        return minIndex;
    }
});
​
app.MapPost("/Directory", (string[] files) =>
{
    DirectoryResponse result = new DirectoryResponse();
    for (int i = 0; i < files.Length; i++)
    {
        FilePathData filePathData = GetFilePathData(files[i]);
        DirectoryResponse parent = result;
        for (int j = 0; j < filePathData.ParentDirectoryLevel.Count; j++)
        {
            int index = FindIndex(parent.SubDirectories, filePathData.ParentDirectoryLevel[j]);
            if (index >= 0)
            {
                parent = parent.SubDirectories[index];
            }
            else
            {
                var dir = new DirectoryResponse();
                dir.Name = filePathData.ParentDirectoryLevel[j];
                parent.SubDirectories.Add(dir);
                parent = dir;
            }
        }
        parent.Files.Add(filePathData.FileName);
    }
​
    return Results.Json(result);
​
    FilePathData GetFilePathData(string file)
    {
        FilePathData result = new FilePathData();
        string[] split = file.Split("\\");
        int i = 0;
        for (; i < split.Length - 1; i++)
        {
            result.ParentDirectoryLevel.Add(split[i]);
        }
        result.FileName = split[i];
        return result;
    }
​
    int FindIndex(List<DirectoryResponse> list, string name)
    {
        for (int i = 0; i < list.Count; i++)
        {
            if (list[i].Name == name)
                return i;
        }
        return -1;
    }
});
​
app.MapPost("/FindExclusive", (int[][] numbers) =>
{
    int[] left = new int[numbers.Length];
    int[] right = new int[numbers.Length];
    for (int i = 0;i < numbers.Length; i++)
    {
        var element = numbers[i];
        left[i] = element[0];
        right[i] = element[1];
    }
    Dictionary<int, int> rightNumbers = new Dictionary<int, int>();
    for (int i = 0; i < right.Length; i++)
    {
        if (rightNumbers.ContainsKey(right[i]))
        {
            right[i] = right[i] + 1;
        }
        else
        {
            rightNumbers.Add(right[i], 1);
        }
    }
    for (int i = 0; i < left.Length; i++)
    {
        if (rightNumbers.ContainsKey(left[i]))
        {
            rightNumbers.Remove(left[i]);
        }
    }
    int[] result = rightNumbers.Keys.ToArray();
    return Results.Json(result);
});
​
app.MapPost("/FindCommon", (int[][] numbers) =>
{
    int[] left = new int[numbers.Length];
    int[] right = new int[numbers.Length];
    for (int i = 0; i < numbers.Length; i++)
    {
        var element = numbers[i];
        left[i] = element[0];
        right[i] = element[1];
    }
    Dictionary<int, int> keyReducer = new Dictionary<int, int>();
    for (int i = 0; i < right.Length; i++)
    {
        if (!keyReducer.ContainsKey(right[i]))
        {
            keyReducer.Add(right[i], 0);
        }
    }
    for (int i = 0; i < left.Length; i++)
    {
        if (keyReducer.ContainsKey(left[i]))
        {
            keyReducer[left[i]] = 1;
        }
    }
    int[] keys = keyReducer.Keys.ToArray();
    List<int> intersectionResult = new List<int>();
    for (int i = 0; i < keys.Length; i++)
    {
        int key = keys[i];
        if (keyReducer[key] > 0)
        {
            intersectionResult.Add(key);
        }
    }
    int[] result = new int[intersectionResult.Count];
    for (int i = 0; i < intersectionResult.Count; i++)
    {
        result[i] = intersectionResult[i];
    }
    return Results.Json(result);
});
​
app.MapPost("/FindAll", (int[][] numbers) =>
{
    int[] left = new int[numbers.Length];
    int[] right = new int[numbers.Length];
    for (int i = 0; i < numbers.Length; i++)
    {
        var element = numbers[i];
        left[i] = element[0];
        right[i] = element[1];
    }
    Dictionary<int, int> keyAccumulator = new Dictionary<int, int>();
    for (int i = 0; i < right.Length; i++)
    {
        if (keyAccumulator.ContainsKey(right[i]))
        {
            right[i] = right[i] + 1;
        }
        else
        {
            keyAccumulator.Add(right[i], 1);
        }
    }
    for (int i = 0; i < left.Length; i++)
    {
        if (keyAccumulator.ContainsKey(left[i]))
        {
            left[i] = left[i] + 1;
        }
        else
        {
            keyAccumulator.Add(left[i], 1);
        }
    }
    int[] result = keyAccumulator.Keys.ToArray();
    return Results.Json(result);
});
​
app.Run();
​
class FormatNumberRangeModel
{
    public int Low { get; set; }
    public int High { get; set; }
}
​
class PaginationRequest
{
    public int[] AllRows { get; set; } = new int[0];
    public int PageIndex { get; set; }
    public int PageSize { get; set; }
}
​
class PaginationResponse
{
    public int[] CurrentPageRows { get; set; } = new int[0];
    public int From { get; set; }
    public int To { get; set; }
    public int Total { get; set; }
}
​
class URIResponse
{
    public string Scheme { get; set; } = string.Empty;
    public string UserInfo { get; set; } = string.Empty;
    public string Host { get; set; } = string.Empty;
    public string Port { get; set; } = string.Empty;
    public string Path { get; set; } = string.Empty;
    public string Query { get; set; } = string.Empty;
    public string Fragment { get; set; } = string.Empty;
}
​
class DirectoryResponse
{
    public string Name { get; set; } = string.Empty;
    public List<DirectoryResponse> SubDirectories { get; set; } = new List<DirectoryResponse>();
    public List<string> Files { get; set; } = new List<string>();
}
​
class FilePathData
{
    public List<string> ParentDirectoryLevel { get; set; } = new List<string>();
    public string FileName { get; set; } = string.Empty;
}

45
45
True

Cached Result
Last Run:	12:04:06 pm
Compile:	0.28s
Execute:	0.28s
Memory:	19.18Mb
CPU:	0.56s

View IL Code