Gülteg Anagram Leetcode Léisung

Problem Ausso Gülteg Anagram Leetcode Léisung - Gitt zwee Saiten s an t, gitt richteg zréck wann t en Anagram vun s ass, a falsch anescht. En Anagram ass e Wuert oder Ausdrock geformt andeems d'Bréiwer vun engem anere Wuert oder Ausdrock nei arrangéiert ginn, typesch all d'Original Buschtawen exakt eemol benotzt. Beispill 1: Input: s = "anagram", t = "nagaram" Ausgang: ...

méi liesen

Isomorphic Strings LeetCode Léisung

Problem Ausso Isomorphic Strings LeetCode Léisung - Gitt zwee Saiten s an t, bestëmmen ob se isomorph sinn. Zwee Saiten s an t sinn isomorphic wann d'Zeechen an s ersat ginn t ze kréien. All Optriede vun engem Charakter muss duerch en anere Charakter ersat ginn, wärend d'Uerdnung vun de Charaktere behalen. Keng zwee Zeechen däerfen op de…

méi liesen

Monotonic Array Leetcode Léisung

Problem Ausso: Déi monotonesch Array Leetcode Léisung - Gitt eng Array ass monoton wann et entweder monoton eropgeet oder monoton erofgaang ass. Eng Array nums ass monoton eropgaang wann fir all i <= j, nums[i] <= nums[j]. Eng Array nums ass monoton erofgaang wann fir all i <= j, nums[i] >= nums[j]. Gitt eng ganzer Array Zuelen, gitt richteg zréck wann de gegebene ...

méi liesen

Héich Fënnef LeetCode Léisung

Problem Ausso: D'High Five LeetCode Léisung - Gitt eng Lëscht vu Partituren vu verschiddene Studenten mam Numm "Artikel", wou den "Artikel" zwee Felder huet Element[0] representéiert d'Id vum Student, an Element [1] representéiert de Score vum Student zB. item[i]=[IDi, SCOREi] Gitt d'Äntwert als Array vu Pairen zréck, wou Resultat[j] = ...

méi liesen

Range Zomm vun BST LeetCode Léisung

Range Sum of BST LeetCode Solution seet dat - Gitt d'Wuerzel vum Node vun engem binäre Sichbam an zwee ganz Zuelen niddereg an héich, gitt d'Zomm vun de Wäerter vun all Wirbelen mat engem Wäert am inklusiv Beräich [niddereg, héich]. Beispill 1: Input: root = [10,5,15,3,7,null,18], niddereg = 7, héich = 15 Ausgang: 32 Erklärung: ...

méi liesen

Rotéieren String LeetCode Léisung

Problem Ausso Rotatioun String LeetCode Léisung - Ginn zwee Saiten s an Zil, zréck wouer wann an nëmmen wann s Goal kann no puer Zuel vun Verréckelung op s ginn. Eng Verréckelung op s besteet aus der Beweegung vum lénkste Charakter vun s op déi riets Positioun. Zum Beispill, wann s = "abcde", da wäert et ...

méi liesen

Rechteck Iwwerlappung LeetCode Léisung

Problem Ausso: Rechteck Iwwerlappung LeetCode Léisung - seet datt en Achs-ausgeriichtte Rechteck als Lëscht vertruede gëtt, [x1, y1, x2, y2], wou (x1, y1) d'Koordinat vu sengem ënneschten lénksen Eck ass, an (x2) , y2) ass d'Koordinate vu sengem uewe rietsen Eck. Seng iewescht an ënnen Kante si parallel zu der X-Achs, a seng lénks ...

méi liesen

Maximum Populatioun Joer LeetCode Léisung

Problem Ausso

Maximum Populatioun Joer LeetCode Léisung seet dat - Dir kritt eng 2D ganzt Zuel logs wou all logs[i] = [birthi, deathi] weist d'Gebuerts- an Doudsjore vun der ith Persoun.

d' Bevëlkerung vun e puer Joer x ass d'Zuel vu Leit déi während deem Joer liewen. Déi ith eng Persoun gëtt am Joer gezielt xd'Bevëlkerung wann x ass an der Inklusiv Rei [birthi, deathi - 1]. Notéiert datt d'Persoun ass net am Joer gezielt, datt si stierwen.

zeréck d'maximal Populatioun Joer.

 

Beispill 1:

Input:

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

Ausgab:

 1993

Erklärung:

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

Beispill 2:

Input:

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

Ausgab:

 1960

Erklärung:

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

 

Aschränkungen:

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

 

ALGORITHME -

  • Fir d'maximal Populatiounsjoer ze fannen. Als éischt konzentréiere mir eis op d'Gesamtzuel vun der Bevëlkerung an all Joer andeems Dir all Intervall vun der gegebener Matrix iwwerpréift a wäert de maximalen Unzuel fannen an d'Joer vum maximale Wäert zréckginn. Wann d'Zuel d'selwecht ass, da gi mer einfach dat Joer virdrun (fréierste Joer) zréck.

Approche fir maximal Populatioun Joer LeetCode Léisung

- Als éischt wäerte mir eng Array vun der Gréisst 101 erstellen, well d'Beschränkunge vu Joeren am Beräich vun 1950 bis 2050 leien.

- duerno lafen mir eng Loop vun 0 op d'Längt vun de Logbicher a wäerten d'Unzuel vun der Array am Index (Logbicher[i][o]) ëm 1 erhéijen an d'Unzuel vun der Array am Index erofsetzen (Logbicher[i] ][1]) vum 1

- erëm wäerte mir eng Loop vun 0 op d'Längt vun der Array lafen an eng Variabel Prev Count maachen an all Element vun der Array aktualiséieren duerch Array+prev an update prev by prev = Array[i].

- Endlech wäerte mir eng Loop lafen an de maximale Wäert an der Array fannen an dee bestëmmten Index zréckginn (Index + 1950). Dofir fannen déi maximal Populatioun Joer.

Maximum Populatioun Joer Leetcode Léisung

Code:

Maximum Populatioun Joer Python Leetcode Léisung:

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

Maximum Populatioun Joer Java Leetcode Léisung:

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;
        
        
    }
}

Komplexitéit Analyse vun Maximum Populatioun Joer Leetcode Léisung:

Zäit Komplexitéit

D'Zäitkomplexitéit vun der uewe genannter Léisung ass O(n).

Zäit Komplexitéit

D'Raumkomplexitéit vun der uewe genannter Léisung ass O(1).

Wéi mir eng Array vu Längt = 101 gemaach hunn. Also kënne mir et konstant betruechten

 

 

 

 

 

 

Translate »