ਟਾਊਨ ਜੱਜ ਲੀਟਕੋਡ ਹੱਲ ਲੱਭੋ

ਸਮੱਸਿਆ ਬਿਆਨ: ਟਾਊਨ ਜੱਜ ਲੀਟਕੋਡ ਹੱਲ ਲੱਭੋ: ਇੱਕ ਕਸਬੇ ਵਿੱਚ, 1 ਤੋਂ n ਤੱਕ ਲੇਬਲ ਕੀਤੇ n ਲੋਕ ਹੁੰਦੇ ਹਨ। ਇੱਕ ਅਫਵਾਹ ਹੈ ਕਿ ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿਅਕਤੀ ਗੁਪਤ ਰੂਪ ਵਿੱਚ ਸ਼ਹਿਰ ਦਾ ਜੱਜ ਹੈ। ਜੇਕਰ ਟਾਊਨ ਜੱਜ ਮੌਜੂਦ ਹੈ, ਤਾਂ: ਟਾਊਨ ਜੱਜ ਕਿਸੇ 'ਤੇ ਭਰੋਸਾ ਨਹੀਂ ਕਰਦਾ। ਹਰ ਕੋਈ (ਟਾਊਨ ਜੱਜ ਨੂੰ ਛੱਡ ਕੇ) ਟਾਊਨ ਜੱਜ 'ਤੇ ਭਰੋਸਾ ਕਰਦਾ ਹੈ। …

ਹੋਰ ਪੜ੍ਹੋ

ਨਿਰੰਤਰ ਸੁਬਾਰੇ ਜੋੜ ਲੀਟਕੋਡ ਹੱਲ

ਸਮੱਸਿਆ ਕਥਨ ਨਿਰੰਤਰ ਸੁਬੈਰੇ ਜੋੜ ਲੀਟਕੋਡ ਹੱਲ – ਇੱਕ ਪੂਰਨ ਅੰਕ ਐਰੇ ਨੰਬਰਾਂ ਅਤੇ ਇੱਕ ਪੂਰਨ ਅੰਕ k ਦਿੱਤੇ ਜਾਣ 'ਤੇ, ਸਹੀ ਵਾਪਸ ਕਰੋ ਜੇਕਰ ਸੰਖਿਆਵਾਂ ਵਿੱਚ ਘੱਟੋ-ਘੱਟ ਦੋ ਦੇ ਆਕਾਰ ਦਾ ਇੱਕ ਨਿਰੰਤਰ ਸਬਰੇ ਹੈ ਜਿਸ ਦੇ ਤੱਤ k ਦੇ ਗੁਣਜ ਤੱਕ ਜੋੜਦੇ ਹਨ, ਜਾਂ ਗਲਤ ਹੈ। ਇੱਕ ਪੂਰਨ ਅੰਕ x k ਦਾ ਗੁਣਜ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਕੋਈ ਪੂਰਨ ਅੰਕ n ਮੌਜੂਦ ਹੈ ਜਿਵੇਂ ਕਿ x = n * k। 0 ਹਮੇਸ਼ਾ ਇੱਕ ਹੁੰਦਾ ਹੈ…

ਹੋਰ ਪੜ੍ਹੋ

ਸਿਖਰ ਦੇ K ਫ੍ਰੀਕੁਐਂਟ ਐਲੀਮੈਂਟਸ ਲੀਟਕੋਡ ਹੱਲ

ਸਮੱਸਿਆ ਬਿਆਨ ਟੌਪ K ਫ੍ਰੀਕੁਐਂਟ ਐਲੀਮੈਂਟਸ ਲੀਟਕੋਡ ਹੱਲ ਕਹਿੰਦਾ ਹੈ ਕਿ - ਇੱਕ ਪੂਰਨ ਅੰਕ ਐਰੇ ਨੰਬਰ ਅਤੇ ਇੱਕ ਪੂਰਨ ਅੰਕ k ਦਿੱਤੇ ਜਾਣ 'ਤੇ, k ਸਭ ਤੋਂ ਵੱਧ ਵਾਰ-ਵਾਰ ਤੱਤ ਵਾਪਸ ਕਰੋ। ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਕ੍ਰਮ ਵਿੱਚ ਜਵਾਬ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ 1: ਇੰਪੁੱਟ: ਸੰਖਿਆ = [1,1,1,2,2,3], k = 2 ਆਉਟਪੁੱਟ: [1,2] ਉਦਾਹਰਨ 2: ਇੰਪੁੱਟ: ਸੰਖਿਆ = [1], k = 1 ਆਉਟਪੁੱਟ: [1] …

ਹੋਰ ਪੜ੍ਹੋ

ਜੰਪ ਗੇਮ IV ਲੀਟਕੋਡ ਹੱਲ

ਸਮੱਸਿਆ ਬਿਆਨ: ਜੰਪ ਗੇਮ IV ਲੀਟਕੋਡ ਹੱਲ ਕਹਿੰਦਾ ਹੈ - ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਐਰੇ ਨੂੰ ਵੇਖਦਿਆਂ, ਤੁਸੀਂ ਅਰੰਭ ਵਿੱਚ ਐਰੇ ਦੇ ਪਹਿਲੇ ਸੂਚਕਾਂਕ 'ਤੇ ਸਥਿਤ ਹੋ। ਇੱਕ ਕਦਮ ਵਿੱਚ ਤੁਸੀਂ ਸੂਚਕਾਂਕ i ਤੋਂ ਸੂਚਕਾਂਕ ਵਿੱਚ ਜਾ ਸਕਦੇ ਹੋ: i + 1 ਜਿੱਥੇ: i + 1 < arr.length. i – 1 ਜਿੱਥੇ: i – 1 >= …

ਹੋਰ ਪੜ੍ਹੋ

ਸਭ ਤੋਂ ਛੋਟਾ ਅਣ-ਛਾਂਟਿਆ ਨਿਰੰਤਰ ਸੁਬੈਰੇ ਲੀਟਕੋਡ ਹੱਲ

ਸਮੱਸਿਆ ਬਿਆਨ ਸਭ ਤੋਂ ਛੋਟਾ ਅਣ-ਛਾਂਟਿਆ ਹੋਇਆ ਨਿਰੰਤਰ ਸੁਬੈਰੇ ਲੀਟਕੋਡ ਹੱਲ ਕਹਿੰਦਾ ਹੈ ਕਿ - ਇੱਕ ਪੂਰਨ ਅੰਕ ਐਰੇ ਨੰਬਰ ਦਿੱਤੇ ਜਾਣ 'ਤੇ, ਤੁਹਾਨੂੰ ਇੱਕ ਨਿਰੰਤਰ ਸਬੈਰੇ ਨੂੰ ਲੱਭਣਾ ਪਏਗਾ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਸਬੈਰੇ ਨੂੰ ਸਿਰਫ਼ ਚੜ੍ਹਦੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰਦੇ ਹੋ, ਤਾਂ ਪੂਰੀ ਐਰੇ ਨੂੰ ਵੱਧਦੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਭ ਤੋਂ ਛੋਟੀ ਸਬਰੇ ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਕਰੋ। ਉਦਾਹਰਨ 1:…

ਹੋਰ ਪੜ੍ਹੋ

ਜੋੜ ਰੂਟ ਤੋਂ ਲੈਫ ਨੰਬਰ ਲੀਟਕੋਡ ਹੱਲ

ਸਮੱਸਿਆ ਕਥਨ ਜੋੜ ਰੂਟ ਟੂ ਲੀਫ ਨੰਬਰ ਲੀਟਕੋਡ ਹੱਲ ਕਹਿੰਦਾ ਹੈ - ਤੁਹਾਨੂੰ ਇੱਕ ਬਾਈਨਰੀ ਟ੍ਰੀ ਦੀ ਜੜ੍ਹ ਦਿੱਤੀ ਗਈ ਹੈ ਜਿਸ ਵਿੱਚ ਸਿਰਫ 0 ਤੋਂ 9 ਤੱਕ ਅੰਕ ਹਨ। ਰੁੱਖ ਵਿੱਚ ਹਰੇਕ ਜੜ੍ਹ ਤੋਂ ਪੱਤਾ ਮਾਰਗ ਇੱਕ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਰੂਟ-ਟੂ-ਲੀਫ ਮਾਰਗ 1 -> 2 -> 3 ਨੰਬਰ 123 ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਸਾਰੇ ਰੂਟ-ਟੂ-ਲੀਫ ਨੰਬਰਾਂ ਦਾ ਕੁੱਲ ਜੋੜ ਵਾਪਸ ਕਰੋ। ਟੈਸਟ…

ਹੋਰ ਪੜ੍ਹੋ

ਬਰੈਕਟ ਦਾ ਸਕੋਰ LeetCode ਹੱਲ

ਸਮੱਸਿਆ ਬਿਆਨ ਬਰੈਕਟ ਦਾ ਸਕੋਰ ਲੀਟਕੋਡ ਹੱਲ ਕਹਿੰਦਾ ਹੈ - ਸੰਤੁਲਿਤ ਬਰੈਕਟ ਦਿੱਤੇ ਜਾਣ 'ਤੇ ਸਤਰ s ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਸਕੋਰ ਵਾਪਸ ਕਰੋ। ਸੰਤੁਲਿਤ ਬਰੈਕਟ ਸਤਰ ਦਾ ਸਕੋਰ ਹੇਠਾਂ ਦਿੱਤੇ ਨਿਯਮਾਂ 'ਤੇ ਅਧਾਰਤ ਹੈ: “()” ਦਾ ਸਕੋਰ 1 ਹੈ। AB ਦਾ ਸਕੋਰ A + B ਹੈ, ਜਿੱਥੇ A ਅਤੇ B ਸੰਤੁਲਿਤ ਬਰੈਕਟ ਸਤਰ ਹਨ। (A) ਦਾ ਸਕੋਰ 2 * A ਹੈ, ਜਿੱਥੇ A ਹੈ…

ਹੋਰ ਪੜ੍ਹੋ

ਆਇਤਕਾਰ ਓਵਰਲੈਪ ਲੀਟਕੋਡ ਹੱਲ

ਸਮੱਸਿਆ ਬਿਆਨ: ਆਇਤਕਾਰ ਓਵਰਲੈਪ ਲੀਟਕੋਡ ਹੱਲ - ਕਹਿੰਦਾ ਹੈ ਕਿ ਇੱਕ ਧੁਰੀ-ਅਲਾਈਨਡ ਆਇਤ ਨੂੰ ਇੱਕ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, [x1, y1, x2, y2], ਜਿੱਥੇ (x1, y1) ਇਸਦੇ ਹੇਠਲੇ-ਖੱਬੇ ਕੋਨੇ ਦਾ ਕੋਆਰਡੀਨੇਟ ਹੈ, ਅਤੇ (x2) , y2) ਇਸਦੇ ਉੱਪਰ-ਸੱਜੇ ਕੋਨੇ ਦਾ ਕੋਆਰਡੀਨੇਟ ਹੈ। ਇਸਦੇ ਉਪਰਲੇ ਅਤੇ ਹੇਠਲੇ ਕਿਨਾਰੇ X-ਧੁਰੇ ਦੇ ਸਮਾਨਾਂਤਰ ਹਨ, ਅਤੇ ਇਸਦੇ ਖੱਬੇ ...

ਹੋਰ ਪੜ੍ਹੋ

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਲੀਟਕੋਡ ਹੱਲ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਲੀਟਕੋਡ ਹੱਲ ਕਹਿੰਦਾ ਹੈ ਕਿ - ਤੁਹਾਨੂੰ ਇੱਕ 2D ਪੂਰਨ ਅੰਕ ਐਰੇ ਦਿੱਤਾ ਗਿਆ ਹੈ logs ਜਿੱਥੇ ਹਰ ਇਕ logs[i] = [birthi, deathi] ਦੇ ਜਨਮ ਅਤੇ ਮੌਤ ਦੇ ਸਾਲਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ith ਵਿਅਕਤੀ

The ਕੁਝ ਸਾਲ ਦੀ ਆਬਾਦੀ x ਉਸ ਸਾਲ ਦੌਰਾਨ ਜਿਊਂਦੇ ਲੋਕਾਂ ਦੀ ਸੰਖਿਆ ਹੈ। ਦ 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

 

ਐਲਗੋਰਿਥਮ -

  • ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਦਾ ਸਾਲ ਲੱਭਣ ਲਈ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦਿੱਤੇ ਮੈਟ੍ਰਿਕਸ ਦੇ ਹਰੇਕ ਅੰਤਰਾਲ ਦੀ ਜਾਂਚ ਕਰਕੇ ਹਰ ਸਾਲ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਆਬਾਦੀ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਾਂਗੇ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਲੱਭਾਂਗੇ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਦਾ ਸਾਲ ਵਾਪਸ ਕਰਾਂਗੇ। ਜੇਕਰ ਗਿਣਤੀ ਇੱਕੋ ਜਿਹੀ ਹੈ ਤਾਂ ਅਸੀਂ ਸਿਰਫ਼ ਪਿਛਲੇ ਸਾਲ (ਸ਼ੁਰੂਆਤੀ ਸਾਲ) ਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹਾਂ।

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਲੀਟਕੋਡ ਹੱਲ ਲਈ ਪਹੁੰਚ

- ਪਹਿਲਾਂ, ਅਸੀਂ ਆਕਾਰ 101 ਦੀ ਇੱਕ ਐਰੇ ਬਣਾਵਾਂਗੇ ਕਿਉਂਕਿ ਸਾਲਾਂ ਦੀਆਂ ਪਾਬੰਦੀਆਂ 1950 ਤੋਂ 2050 ਦੀ ਰੇਂਜ ਵਿੱਚ ਹਨ।

- ਉਸ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ 0 ਤੋਂ ਲੌਗਸ ਦੀ ਲੰਬਾਈ ਤੱਕ ਇੱਕ ਲੂਪ ਚਲਾਵਾਂਗੇ ਅਤੇ ਸੂਚਕਾਂਕ (ਲੌਗਸ[i][o]) 'ਤੇ ਐਰੇ ਦੀ ਗਿਣਤੀ ਨੂੰ 1 ਤੱਕ ਵਧਾਵਾਂਗੇ ਅਤੇ ਸੂਚਕਾਂਕ (ਲੌਗਸ[i]) 'ਤੇ ਐਰੇ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਵਾਂਗੇ। [1]) 1 ਦੁਆਰਾ

- ਦੁਬਾਰਾ ਅਸੀਂ ਐਰੇ ਦੀ ਲੰਬਾਈ ਤੱਕ 0 ਤੋਂ ਇੱਕ ਲੂਪ ਚਲਾਵਾਂਗੇ ਅਤੇ ਇੱਕ ਵੇਰੀਏਬਲ ਪ੍ਰੀਵ ਕਾਉਂਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਐਰੇ ਦੇ ਹਰੇਕ ਐਲੀਮੈਂਟ ਨੂੰ ਐਰੇ+ਪ੍ਰੀਵ ਦੁਆਰਾ ਅਪਡੇਟ ਕਰਾਂਗੇ ਅਤੇ ਪ੍ਰੀਵ = ਐਰੇ[i] ਦੁਆਰਾ ਅੱਪਡੇਟ ਕਰਾਂਗੇ।

- ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਲੂਪ ਚਲਾਵਾਂਗੇ ਅਤੇ ਐਰੇ ਵਿੱਚ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਲੱਭਾਂਗੇ ਅਤੇ ਉਸ ਖਾਸ ਸੂਚਕਾਂਕ (ਇੰਡੈਕਸ+1950) ਨੂੰ ਵਾਪਸ ਕਰਾਂਗੇ। ਇਸ ਲਈ ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਦਾ ਸਾਲ ਲੱਭੋ।

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਲੀਟਕੋਡ ਹੱਲ

ਕੋਡ:

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਪਾਈਥਨ ਲੀਟਕੋਡ ਹੱਲ:

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

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਜਾਵਾ ਲੀਟਕੋਡ ਹੱਲ:

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

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਲੀਟਕੋਡ ਹੱਲ ਦਾ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ:

ਟਾਈਮ ਜਟਿਲਤਾ

ਉਪਰੋਕਤ ਹੱਲ ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ O(n) ਹੈ।

ਟਾਈਮ ਜਟਿਲਤਾ

ਉਪਰੋਕਤ ਘੋਲ ਦੀ ਸਪੇਸ ਜਟਿਲਤਾ O(1) ਹੈ।

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਲੰਬਾਈ = 101 ਦੀ ਇੱਕ ਐਰੇ ਬਣਾਈ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਇਸਨੂੰ ਸਥਿਰ ਮੰਨ ਸਕਦੇ ਹਾਂ

 

 

 

 

 

 

ਬਾਈਨਰੀ ਟ੍ਰੀ ਇਨਆਰਡਰ ਟ੍ਰੈਵਰਸਲ ਲੀਟਕੋਡ ਹੱਲ

ਸਮੱਸਿਆ ਬਿਆਨ: ਬਾਈਨਰੀ ਟ੍ਰੀ ਇਨਆਰਡਰ ਟਰਾਵਰਸਲ ਲੀਟਕੋਡ ਹੱਲ ਇੱਕ ਬਾਈਨਰੀ ਟ੍ਰੀ ਦੇ ਰੂਟ ਨੂੰ ਵੇਖਦੇ ਹੋਏ, ਇਸਦੇ ਨੋਡਸ ਦੇ ਮੁੱਲਾਂ ਦਾ ਇਨਆਰਡਰ ਟ੍ਰਾਵਰਸਲ ਵਾਪਸ ਕਰੋ। ਉਦਾਹਰਨ 1: ਇਨਪੁਟ: ਰੂਟ = [1,ਨਲ,2,3] ਆਉਟਪੁੱਟ: [1,3,2] ਉਦਾਹਰਨ 2: ਇਨਪੁਟ: ਰੂਟ = [] ਆਉਟਪੁੱਟ: [] ਉਦਾਹਰਨ 3: ਇਨਪੁਟ: ਰੂਟ = [1] ਆਉਟਪੁੱਟ: [1] ਪਾਬੰਦੀਆਂ: ਵਿੱਚ ਨੋਡਾਂ ਦੀ ਗਿਣਤੀ ...

ਹੋਰ ਪੜ੍ਹੋ

Translate »