< 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
94%
Covered lines: 101
Uncovered lines: 6
Coverable lines: 107
Total lines: 273
Line coverage: 94.3%
Branch coverage
83%
Covered branches: 20
Total branches: 24
Branch coverage: 83.3%
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(...)75%8880.95%
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;
 119    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>
 128    public DesignMovieRentalSystemDictionary(int n, int[][] entries)
 129    {
 130        var entriesLength = entries.Length;
 31
 132        _movieToMovieOffersDictionary = new Dictionary<int, SortedSet<MovieOffer>>(entriesLength);
 133        _shopMovieToPriceDictionary = new Dictionary<(int Shop, int Movie), int>(entriesLength);
 34
 1435        for (var i = 0; i < entriesLength; i++)
 636        {
 637            var entry = entries[i];
 638            var shop = entry[0];
 639            var movie = entry[1];
 640            var price = entry[2];
 41
 642            _shopMovieToPriceDictionary.Add((shop, movie), price);
 43
 644            if (!_movieToMovieOffersDictionary.TryGetValue(movie, out var movieOffers))
 345            {
 346                movieOffers = [];
 47
 348                _movieToMovieOffersDictionary[movie] = movieOffers;
 349            }
 50
 651            movieOffers.Add(new MovieOffer(price, shop));
 652        }
 153    }
 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)
 262    {
 263        if (!_movieToMovieOffersDictionary.TryGetValue(movie, out var movieOffers))
 064        {
 065            return [];
 66        }
 67
 268        var movieOffersCount = movieOffers.Count;
 69
 270        if (movieOffersCount == 0)
 071        {
 072            return [];
 73        }
 74
 275        var searchResultsCount = Math.Min(movieOffersCount, ResultsCount);
 76
 277        var searchResults = new int[searchResultsCount];
 78
 279        var searchResultsIndex = 0;
 80
 1481        foreach (var movieOffer in movieOffers)
 582        {
 583            searchResults[searchResultsIndex] = movieOffer.Shop;
 84
 585            searchResultsIndex++;
 86
 587            if (searchResultsIndex == searchResultsCount)
 288            {
 289                break;
 90            }
 391        }
 92
 293        return searchResults;
 294    }
 95
 96    /// <summary>
 97    ///     Time complexity - O(1)
 98    ///     Space complexity - O(1)
 99    /// </summary>
 100    /// <returns></returns>
 101    public IList<IList<int>> Report()
 1102    {
 1103        var rentalItemsCount = _rentalRecordsSortedSet.Count;
 104
 1105        if (rentalItemsCount == 0)
 0106        {
 0107            return [];
 108        }
 109
 1110        var reportResultsCount = Math.Min(rentalItemsCount, ResultsCount);
 111
 1112        var reportResults = new IList<int>[reportResultsCount];
 113
 1114        var reportResultsIndex = 0;
 115
 6116        foreach (var rentalItem in _rentalRecordsSortedSet)
 2117        {
 2118            reportResults[reportResultsIndex] = rentalItem.GetReport();
 119
 2120            reportResultsIndex++;
 121
 2122            if (reportResultsIndex == reportResultsCount)
 1123            {
 1124                break;
 125            }
 1126        }
 127
 1128        return reportResults;
 1129    }
 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)
 2138    {
 2139        var price = _shopMovieToPriceDictionary[(shop, movie)];
 140
 2141        _rentalRecordsSortedSet.Add(new RentalRecord(shop, movie, price));
 142
 2143        var movieOffers = _movieToMovieOffersDictionary[movie];
 144
 2145        movieOffers.Remove(new MovieOffer(price, shop));
 2146    }
 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)
 1155    {
 1156        var price = _shopMovieToPriceDictionary[(shop, movie)];
 157
 1158        _rentalRecordsSortedSet.Remove(new RentalRecord(shop, movie, price));
 159
 1160        var movieOffers = _movieToMovieOffersDictionary[movie];
 161
 1162        movieOffers.Add(new MovieOffer(price, shop));
 1163    }
 164
 25165    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)
 7174        {
 7175            var priceComparison = CompareToPrice(movieOffer.Price);
 176
 7177            return priceComparison != 0 ? priceComparison : CompareToShop(movieOffer.Shop);
 7178        }
 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)
 7187        {
 7188            return Price.CompareTo(price);
 7189        }
 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)
 3198        {
 3199            return Shop.CompareTo(shop);
 3200        }
 201    }
 202
 14203    private readonly record struct RentalRecord(int Shop, int Movie, int Price) : IComparable<RentalRecord>
 204    {
 3205        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)
 3214        {
 3215            var priceComparison = CompareToPrice(rentalRecord.Price);
 216
 3217            if (priceComparison != 0)
 2218            {
 2219                return priceComparison;
 220            }
 221
 1222            var shopComparison = CompareToShop(rentalRecord.Shop);
 223
 1224            return shopComparison != 0 ? shopComparison : CompareToMovie(rentalRecord.Movie);
 3225        }
 226
 227        /// <summary>
 228        ///     Time complexity - O(1)
 229        ///     Space complexity - O(1)
 230        /// </summary>
 231        /// <returns></returns>
 232        public int[] GetReport()
 2233        {
 2234            _report[0] = Shop;
 2235            _report[1] = Movie;
 236
 2237            return _report;
 2238        }
 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)
 3247        {
 3248            return Price.CompareTo(price);
 3249        }
 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)
 1258        {
 1259            return Shop.CompareTo(shop);
 1260        }
 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)
 1269        {
 1270            return Movie.CompareTo(movie);
 1271        }
 272    }
 273}
Generated by: ReportGenerator 5.5.4.0
4/1/2026 - 8:25:09 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)