< Summary

Information
Class: LeetCode.Algorithms.DesignMovieRentalSystem.DesignMovieRentalSystemDictionary
Assembly: LeetCode
File(s): D:\a\LeetCode-CS\LeetCode-CS\source\LeetCode\Algorithms\DesignMovieRentalSystem\DesignMovieRentalSystemDictionary.cs
Line coverage
96%
Covered lines: 103
Uncovered lines: 4
Coverable lines: 107
Total lines: 273
Line coverage: 96.2%
Branch coverage
87%
Covered branches: 21
Total branches: 24
Branch coverage: 87.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%44100%
Search(...)87.5%8890.47%
Report()83.33%6688.88%
Rent(...)100%11100%
Drop(...)100%11100%
get_Price()100%11100%
CompareTo(...)100%22100%
CompareToPrice(...)100%11100%
CompareToShop(...)100%11100%
get_Shop()100%11100%
.ctor(...)100%11100%
CompareTo(...)75%44100%
GetReport()100%11100%
CompareToPrice(...)100%11100%
CompareToShop(...)100%11100%
CompareToMovie(...)100%11100%

File(s)

D:\a\LeetCode-CS\LeetCode-CS\source\LeetCode\Algorithms\DesignMovieRentalSystem\DesignMovieRentalSystemDictionary.cs

#LineLine coverage
 1// --------------------------------------------------------------------------------
 2// Copyright (C) 2026 Eugene Eremeev (also known as Yevhenii Yeriemeieiv).
 3// All Rights Reserved.
 4// --------------------------------------------------------------------------------
 5// This software is the confidential and proprietary information of Eugene Eremeev
 6// (also known as Yevhenii Yeriemeieiv) ("Confidential Information"). You shall not
 7// disclose such Confidential Information and shall use it only in accordance with
 8// the terms of the license agreement you entered into with Eugene Eremeev (also
 9// known as Yevhenii Yeriemeieiv).
 10// --------------------------------------------------------------------------------
 11
 12namespace LeetCode.Algorithms.DesignMovieRentalSystem;
 13
 14/// <inheritdoc />
 15public sealed class DesignMovieRentalSystemDictionary : IDesignMovieRentalSystem
 16{
 17    private const int ResultsCount = 5;
 18    private readonly Dictionary<int, SortedSet<MovieOffer>> _movieToMovieOffersDictionary;
 419    private readonly SortedSet<RentalRecord> _rentalRecordsSortedSet = [];
 20    private readonly Dictionary<(int Shop, int Movie), int> _shopMovieToPriceDictionary;
 21
 22    /// <summary>
 23    ///     Time complexity - O(m log m), where m is the length of entries
 24    ///     Space complexity - O(m)
 25    /// </summary>
 26    /// <param name="n"></param>
 27    /// <param name="entries"></param>
 428    public DesignMovieRentalSystemDictionary(int n, int[][] entries)
 429    {
 430        var entriesLength = entries.Length;
 31
 432        _movieToMovieOffersDictionary = new Dictionary<int, SortedSet<MovieOffer>>(entriesLength);
 433        _shopMovieToPriceDictionary = new Dictionary<(int Shop, int Movie), int>(entriesLength);
 34
 4635        for (var i = 0; i < entriesLength; i++)
 1936        {
 1937            var entry = entries[i];
 1938            var shop = entry[0];
 1939            var movie = entry[1];
 1940            var price = entry[2];
 41
 1942            _shopMovieToPriceDictionary.Add((shop, movie), price);
 43
 1944            if (!_movieToMovieOffersDictionary.TryGetValue(movie, out var movieOffers))
 845            {
 846                movieOffers = [];
 47
 848                _movieToMovieOffersDictionary[movie] = movieOffers;
 849            }
 50
 1951            movieOffers.Add(new MovieOffer(price, shop));
 1952        }
 453    }
 54
 55    /// <summary>
 56    ///     Time complexity - O(1)
 57    ///     Space complexity - O(1)
 58    /// </summary>
 59    /// <param name="movie"></param>
 60    /// <returns></returns>
 61    public IList<int> Search(int movie)
 562    {
 563        if (!_movieToMovieOffersDictionary.TryGetValue(movie, out var movieOffers))
 064        {
 065            return [];
 66        }
 67
 568        var movieOffersCount = movieOffers.Count;
 69
 570        if (movieOffersCount == 0)
 171        {
 172            return [];
 73        }
 74
 475        var searchResultsCount = Math.Min(movieOffersCount, ResultsCount);
 76
 477        var searchResults = new int[searchResultsCount];
 78
 479        var searchResultsIndex = 0;
 80
 3081        foreach (var movieOffer in movieOffers)
 1182        {
 1183            searchResults[searchResultsIndex] = movieOffer.Shop;
 84
 1185            searchResultsIndex++;
 86
 1187            if (searchResultsIndex == searchResultsCount)
 488            {
 489                break;
 90            }
 791        }
 92
 493        return searchResults;
 594    }
 95
 96    /// <summary>
 97    ///     Time complexity - O(1)
 98    ///     Space complexity - O(1)
 99    /// </summary>
 100    /// <returns></returns>
 101    public IList<IList<int>> Report()
 2102    {
 2103        var rentalItemsCount = _rentalRecordsSortedSet.Count;
 104
 2105        if (rentalItemsCount == 0)
 0106        {
 0107            return [];
 108        }
 109
 2110        var reportResultsCount = Math.Min(rentalItemsCount, ResultsCount);
 111
 2112        var reportResults = new IList<int>[reportResultsCount];
 113
 2114        var reportResultsIndex = 0;
 115
 16116        foreach (var rentalItem in _rentalRecordsSortedSet)
 6117        {
 6118            reportResults[reportResultsIndex] = rentalItem.GetReport();
 119
 6120            reportResultsIndex++;
 121
 6122            if (reportResultsIndex == reportResultsCount)
 2123            {
 2124                break;
 125            }
 4126        }
 127
 2128        return reportResults;
 2129    }
 130
 131    /// <summary>
 132    ///     Time complexity - O(log m), where m is the number of offers for the movie
 133    ///     Space complexity - O(1)
 134    /// </summary>
 135    /// <param name="shop"></param>
 136    /// <param name="movie"></param>
 137    public void Rent(int shop, int movie)
 8138    {
 8139        var price = _shopMovieToPriceDictionary[(shop, movie)];
 140
 8141        _rentalRecordsSortedSet.Add(new RentalRecord(shop, movie, price));
 142
 8143        var movieOffers = _movieToMovieOffersDictionary[movie];
 144
 8145        movieOffers.Remove(new MovieOffer(price, shop));
 8146    }
 147
 148    /// <summary>
 149    ///     Time complexity - O(log m), where m is the number of offers for the movie
 150    ///     Space complexity - O(1)
 151    /// </summary>
 152    /// <param name="shop"></param>
 153    /// <param name="movie"></param>
 154    public void Drop(int shop, int movie)
 2155    {
 2156        var price = _shopMovieToPriceDictionary[(shop, movie)];
 157
 2158        _rentalRecordsSortedSet.Remove(new RentalRecord(shop, movie, price));
 159
 2160        var movieOffers = _movieToMovieOffersDictionary[movie];
 161
 2162        movieOffers.Add(new MovieOffer(price, shop));
 2163    }
 164
 85165    public readonly record struct MovieOffer(int Price, int Shop) : IComparable<MovieOffer>
 166    {
 167        /// <summary>
 168        ///     Time complexity - O(1)
 169        ///     Space complexity - O(1)
 170        /// </summary>
 171        /// <param name="movieOffer"></param>
 172        /// <returns></returns>
 173        public int CompareTo(MovieOffer movieOffer)
 26174        {
 26175            var priceComparison = CompareToPrice(movieOffer.Price);
 176
 26177            return priceComparison != 0 ? priceComparison : CompareToShop(movieOffer.Shop);
 26178        }
 179
 180        /// <summary>
 181        ///     Time complexity - O(1)
 182        ///     Space complexity - O(1)
 183        /// </summary>
 184        /// <param name="price"></param>
 185        /// <returns></returns>
 186        private int CompareToPrice(int price)
 26187        {
 26188            return Price.CompareTo(price);
 26189        }
 190
 191        /// <summary>
 192        ///     Time complexity - O(1)
 193        ///     Space complexity - O(1)
 194        /// </summary>
 195        /// <param name="shop"></param>
 196        /// <returns></returns>
 197        private int CompareToShop(int shop)
 11198        {
 11199            return Shop.CompareTo(shop);
 11200        }
 201    }
 202
 38203    private readonly record struct RentalRecord(int Shop, int Movie, int Price) : IComparable<RentalRecord>
 204    {
 10205        private readonly int[] _report = new int[2];
 206
 207        /// <summary>
 208        ///     Time complexity - O(1)
 209        ///     Space complexity - O(1)
 210        /// </summary>
 211        /// <param name="rentalRecord"></param>
 212        /// <returns></returns>
 213        public int CompareTo(RentalRecord rentalRecord)
 9214        {
 9215            var priceComparison = CompareToPrice(rentalRecord.Price);
 216
 9217            if (priceComparison != 0)
 7218            {
 7219                return priceComparison;
 220            }
 221
 2222            var shopComparison = CompareToShop(rentalRecord.Shop);
 223
 2224            return shopComparison != 0 ? shopComparison : CompareToMovie(rentalRecord.Movie);
 9225        }
 226
 227        /// <summary>
 228        ///     Time complexity - O(1)
 229        ///     Space complexity - O(1)
 230        /// </summary>
 231        /// <returns></returns>
 232        public int[] GetReport()
 6233        {
 6234            _report[0] = Shop;
 6235            _report[1] = Movie;
 236
 6237            return _report;
 6238        }
 239
 240        /// <summary>
 241        ///     Time complexity - O(1)
 242        ///     Space complexity - O(1)
 243        /// </summary>
 244        /// <param name="price"></param>
 245        /// <returns></returns>
 246        private int CompareToPrice(int price)
 9247        {
 9248            return Price.CompareTo(price);
 9249        }
 250
 251        /// <summary>
 252        ///     Time complexity - O(1)
 253        ///     Space complexity - O(1)
 254        /// </summary>
 255        /// <param name="shop"></param>
 256        /// <returns></returns>
 257        private int CompareToShop(int shop)
 2258        {
 2259            return Shop.CompareTo(shop);
 2260        }
 261
 262        /// <summary>
 263        ///     Time complexity - O(1)
 264        ///     Space complexity - O(1)
 265        /// </summary>
 266        /// <param name="movie"></param>
 267        /// <returns></returns>
 268        private int CompareToMovie(int movie)
 2269        {
 2270            return Movie.CompareTo(movie);
 2271        }
 272    }
 273}
Generated by: ReportGenerator 5.5.4.0
4/15/2026 - 11:20:12 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.Int32,System.Int32[][])
Search(System.Int32)
Report()
Rent(System.Int32,System.Int32)
Drop(System.Int32,System.Int32)
get_Price()
CompareTo(LeetCode.Algorithms.DesignMovieRentalSystem.DesignMovieRentalSystemDictionary/MovieOffer)
CompareToPrice(System.Int32)
CompareToShop(System.Int32)
get_Shop()
.ctor(System.Int32,System.Int32,System.Int32)
CompareTo(LeetCode.Algorithms.DesignMovieRentalSystem.DesignMovieRentalSystemDictionary/RentalRecord)
GetReport()
CompareToPrice(System.Int32)
CompareToShop(System.Int32)
CompareToMovie(System.Int32)