იპოვეთ Town Judge LeetCode Solution

პრობლემის ფორმულირება: იპოვეთ ქალაქ მოსამართლე ლიტკოდის ამოხსნა: ქალაქში არის n ადამიანი მონიშნული 1-დან n-მდე. არსებობს ჭორი, რომ ერთ-ერთი მათგანი ფარულად ქალაქის მოსამართლეა. თუ ქალაქის მოსამართლე არსებობს, მაშინ: ქალაქის მოსამართლე არავის ენდობა. ყველა (გარდა ქალაქის მოსამართლისა) ენდობა ქალაქის მოსამართლეს. …

წაიკითხე მეტი

უწყვეტი Subarray Sum LeetCode Solution

პრობლემის ფორმულირება უწყვეტი ქვესარეის ჯამი LeetCode ამოხსნა - მთელი მასივის ნომრის და მთელი რიცხვის k-ის გათვალისწინებით, დააბრუნეთ true, თუ რიცხვებს აქვს უწყვეტი ქვემაივი მინიმუმ ორი ზომის, რომლის ელემენტები აჯამებს k-ის ჯერადს, ან ცრუ. მთელი x არის k-ის ჯერადი, თუ არსებობს მთელი რიცხვი n ისეთი, რომ x = n * k. 0 ყოველთვის არის…

წაიკითხე მეტი

ყველაზე K ხშირი ელემენტები LeetCode Solution

პრობლემის დებულება ზედა K ხშირი ელემენტები LeetCode ამოხსნა ამბობს, რომ - მთელი მასივის ნომრებისა და მთელი რიცხვის k-ის გათვალისწინებით, დააბრუნეთ k ყველაზე ხშირი ელემენტები. პასუხის დაბრუნება შეგიძლიათ ნებისმიერი თანმიმდევრობით. მაგალითი 1: შეყვანა: nums = [1,1,1,2,2,3], k = 2 გამომავალი: [1,2] მაგალითი 2: შეყვანა: nums = [1], k = 1 გამომავალი: [1] …

წაიკითხე მეტი

Jump Game IV LeetCode Solution

პრობლემის განცხადება: Jump Game IV LeetCode Solution ამბობს – მთელი რიცხვების arr მასივის გათვალისწინებით, თქვენ თავდაპირველად განლაგებული ხართ მასივის პირველ ინდექსზე. ერთი ნაბიჯით შეგიძლიათ გადახვიდეთ i ინდექსიდან ინდექსზე: i + 1 სადაც: i + 1 < arr.length. i – 1 სადაც: i – 1 >= …

წაიკითხე მეტი

უმოკლეს დაუხარისხებელი უწყვეტი Subarray LeetCode გადაწყვეტა

პრობლემის ფორმულირება უმოკლეს დაუხარისხებელი უწყვეტი ქვესარეი LeetCode Solution ამბობს, რომ - მთელი მასივის ნომრის გათვალისწინებით, თქვენ უნდა იპოვოთ ერთი უწყვეტი ქვემაივი, რომელიც თუ ამ ქვემაივს მხოლოდ ზრდადი მიმდევრობით დაალაგებთ, მაშინ მთელი მასივი დალაგდება ზრდადი მიმდევრობით. დააბრუნეთ უმოკლეს ქვემაივის სიგრძე. მაგალითი 1:…

წაიკითხე მეტი

ჯამი ფესვიდან ფოთლამდე რიცხვებში LeetCode Solution

ამოცანის ამონაწერი ჯამი ფესვიდან ფოთლის რიცხვამდე LeetCode Solution ამბობს – თქვენ გეძლევათ ორობითი ხის ფესვი, რომელიც შეიცავს მხოლოდ 0-დან 9-მდე ციფრებს. ხეში თითოეული ფესვიდან ფოთლამდე ბილიკი წარმოადგენს რიცხვს. მაგალითად, ფესვიდან ფოთლამდე ბილიკი 1 -> 2 -> 3 წარმოადგენს რიცხვს 123. დააბრუნეთ ყველა ფესვიდან ფოთლის რიცხვის ჯამი. ტესტი…

წაიკითხე მეტი

ფრჩხილების ქულა LeetCode Solution

პრობლემის განცხადება ფრჩხილების LeetCode Solution-ის ქულა ამბობს – მოცემულია დაბალანსებული ფრჩხილების სტრიქონი s და დააბრუნეთ მაქსიმალური ქულა. დაბალანსებული ფრჩხილის სტრიქონის ქულა ეფუძნება შემდეგ წესებს: „()“-ს აქვს ქულა 1. AB-ს აქვს ქულა A + B, სადაც A და B არის დაბალანსებული ფრჩხილების სტრიქონები. (A) აქვს ქულა 2 * A, სადაც A არის…

წაიკითხე მეტი

მართკუთხედის გადახურვა LeetCode გადაწყვეტა

პრობლემის ფორმულირება: მართკუთხედის გადახურვა LeetCode Solution – ამბობს, რომ ღერძზე გასწორებული მართკუთხედი წარმოდგენილია სიაში, [x1, y1, x2, y2], სადაც (x1, y1) არის მისი ქვედა მარცხენა კუთხის კოორდინატი და (x2). , y2) არის მისი ზედა მარჯვენა კუთხის კოორდინატი. მისი ზედა და ქვედა კიდეები X ღერძის პარალელურია, ხოლო მარცხენა ...

წაიკითხე მეტი

მაქსიმალური პოპულაციის წელი LeetCode Solution

პრობლემის განცხადება

მაქსიმალური პოპულაციის წელი LeetCode Solution ამბობს, რომ – გეძლევათ 2D მთელი რიცხვი მასივი logs სადაც თითოეული logs[i] = [birthi, deathi] მიუთითებს დაბადებისა და გარდაცვალების წლები ith პირი.

ის რამდენიმე წლის მოსახლეობა x არის იმ წლის განმავლობაში ცოცხალი ადამიანების რაოდენობა. The ith ადამიანი ითვლება წელში xმოსახლეობის თუ x არის მათ შორის სპექტრი [birthi, deathi - 1]. გაითვალისწინეთ, რომ ადამიანი არის არ ითვლიან იმ წელს, როცა კვდებიან.

დაბრუნების მოსახლეობის მაქსიმალური წელი.

 

მაგალითად 1:

შეყვანის:

 logs = [[1993,1999],[2000,2010]]

გამოყვანის:

 1993

განმარტება:

 The maximum population is 1, and 1993 is the earliest year with this population.

მაგალითად 2:

შეყვანის:

 logs = [[1950,1961],[1960,1971],[1970,1981]]

გამოყვანის:

 1960

განმარტება:

 
The maximum population is 2, and it had happened in years 1960 and 1970.
So the maximum population year is 1960.

 

შეზღუდვები:

  • 1 <= logs.length <= 100
  • 1950 <= birthi < deathi <= 2050

 

ალგორითმი -

  • იმისთვის, რომ ვიპოვოთ მოსახლეობის მაქსიმალური წელი. პირველ რიგში, ჩვენ ყურადღებას გავამახვილებთ თითოეულ წელიწადში პოპულაციის მთლიან რაოდენობაზე მოცემული მატრიცის ყოველი ინტერვალის შემოწმებით და ვიპოვით მაქსიმალურ რაოდენობას და დავაბრუნებთ მაქსიმალური მნიშვნელობის წელს. თუ რაოდენობა იგივეა, ჩვენ უბრალოდ ვაბრუნებთ წინა წელს (უადრესი წელი).

მიდგომა მაქსიმალური მოსახლეობის წლისთვის LeetCode Solution

– პირველ რიგში, ჩვენ შევქმნით 101 ზომის ერთ მასივს, რადგან წლების შეზღუდვები 1950-დან 2050 წლამდე დიაპაზონშია.

– ამის შემდეგ გავუშვებთ ციკლს 0-დან ლოგების სიგრძემდე და გავზრდით მასივის რაოდენობას ინდექსში(logs[i][o]) 1-ით და შევამცირებთ მასივის რაოდენობას ინდექსზე (logs[i ][1]) 1-ით

– ისევ გავუშვებთ ციკლს 0-დან მასივის სიგრძემდე და ვაკეთებთ ერთ ცვლადს prev count და განვაახლებთ მასივის თითოეულ ელემენტს array+prev და განაახლებთ prev prev = array[i]-ით.

– ბოლოს, ჩვენ გავუშვებთ ციკლს და ვიპოვით მაქსიმალურ მნიშვნელობას მასივში და დავაბრუნებთ კონკრეტულ ინდექსს (index+1950). აქედან გამომდინარე, იპოვნეთ მოსახლეობის მაქსიმალური წელი.

მაქსიმალური პოპულაციის წელი Leetcode Solution

კოდი:

მაქსიმალური პოპულაციის წელი პითონის Leetcode გადაწყვეტა:

class Solution:
    def maximumPopulation(self, logs: List[List[int]]) -> int:
        arr = [0]*101
        for i in range(len(logs)):
            
            arr[logs[i][0]-1950] += 1
            
            arr[logs[i][1]-1950] -= 1
            
        
        previous = arr[0]
        for i in range(1,101):
            arr[i] += previous
            previous = arr[i]
            
        print(arr)
        maxi = 0
        ind = 0
        
        for i in range(len(arr)):
            if arr[i] > maxi:
                maxi = arr[i]
                ind = i + 1950
        print(maxi)        
        return ind

მაქსიმალური პოპულაციის წელი Java Leetcode Solution:

class Solution {
    public int maximumPopulation(int[][] logs) {
        
        int[] arr = new int[101];
        for(int i = 0;i < logs.length;i++){
            
            arr[logs[i][0]-1950] +=1;
            arr[logs[i][1]-1950] -=1;
            
            
        }
        
        int prev = arr[0];
        for(int i=1;i<arr.length;i++){
            
            arr[i] += prev;
            prev = arr[i];
            
        }
        
        int ind = 0;
        int maxi = 0;
        
        for(int i=0;i<arr.length;i++){
            
            if(maxi < arr[i]){
                
                maxi = arr[i];
                ind = i+1950;
            }
        }
        
        
        return ind;
        
        
    }
}

მაქსიმალური პოპულაციის წლის Leetcode ამოხსნის სირთულის ანალიზი:

დროის სირთულე

ზემოაღნიშნული ამოხსნის დროის სირთულე არის O(n).

დროის სირთულე

ზემოაღნიშნული ამოხსნის სივრცის სირთულე არის O(1).

როგორც ჩვენ შევქმენით სიგრძის მასივი = 101. ასე რომ, ჩვენ შეგვიძლია ჩავთვალოთ ის მუდმივი

 

 

 

 

 

 

Binary Tree Inorder Traversal LeetCode Solution

პრობლემის ფორმულირება: ორობითი ხის რიგითი გადაკვეთა LeetCode გადაწყვეტა ბინარული ხის ფესვის გათვალისწინებით, დააბრუნეთ მისი კვანძების მნიშვნელობების რიგითი გადაკვეთა. მაგალითი 1: შეყვანა: root = [1,null,2,3] გამომავალი: [1,3,2] მაგალითი 2: შეყვანა: root = [] გამომავალი: [] მაგალითი 3: შეყვანა: root = [1] გამომავალი: [1] შეზღუდვები: კვანძების რაოდენობა…

წაიკითხე მეტი

Translate »