Failed to render content. Please refresh the page. Showing plain-text fallback.
"@/ਕੰਪੋਨੈਂਟਸ/ਸੀਟੀਏ" ਤੋਂ ਸੀਟੀਏ ਆਯਾਤ ਕਰੋ
ਤਕਨੀਕੀ ਇੰਟਰਵਿਊ ਪ੍ਰਸ਼ਨ: ਹੱਲ ਅਤੇ ਉਦਾਹਰਣਾਂ ਨਾਲ ਪੂਰੀ ਗਾਈਡ (2025)
ਆਖਰੀ ਅੱਪਡੇਟ: ਫਰਵਰੀ 6, 2025
ਮੁੱਖ ਟੇਕਵੇਅ
- ਤਕਨੀਕੀ ਇੰਟਰਵਿਊਆਂ ਸਮੱਸਿਆ ਹੱਲ ਕਰਨ, ਕੋਡਿੰਗ ਹੁਨਰਾਂ, ਅਤੇ ਸਿਸਟਮ ਡਿਜ਼ਾਈਨ ਗਿਆਨ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦੀਆਂ ਹਨ
- ਕੋਡਿੰਗ ਹੱਲਾਂ ਤੋਂ ਪਹਿਲਾਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਸਮਝਣ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਤ ਕਰੋ
- ਆਪਣੀ ਸੋਚ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਪਹੁੰਚ ਦਾ ਸਪੱਸ਼ਟ ਰੂਪ ਵਿੱਚ ਵਰਣਨ ਕਰੋ
• ਆਮ ਡੇਟਾ ਢਾਂਚਿਆਂ ਅਤੇ ਐਲਗੋਰਿਦਮ ਦਾ ਨਿਯਮਤ ਅਭਿਆਸ ਕਰੋ
- ਆਪਣੇ ਹੱਲਾਂ ਵਿੱਚ ਸਮੇਂ ਅਤੇ ਸਥਾਨ ਦੀ ਗੁੰਝਲਤਾ 'ਤੇ ਵਿਚਾਰ ਕਰੋ
🎯 ਪ੍ਰੋ ਸੁਝਾਅ: ਤਕਨੀਕੀ ਇੰਟਰਵਿਊ ਤੁਹਾਡੀ ਸਮੱਸਿਆ ਹੱਲ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਪ੍ਰਦਰਸ਼ਤ ਕਰਨ ਬਾਰੇ ਹਨ, ਨਾ ਕਿ ਸਿਰਫ ਸਹੀ ਜਵਾਬ ਪ੍ਰਾਪਤ ਕਰਨਾ. ਇੰਟਰਵਿਊ ਲੈਣ ਵਾਲੇ ਇਹ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਕਿਵੇਂ ਸੋਚਦੇ ਹੋ, ਗੁੰਝਲਦਾਰ ਸਮੱਸਿਆਵਾਂ ਤੱਕ ਪਹੁੰਚਦੇ ਹੋ, ਅਤੇ ਤਕਨੀਕੀ ਸੰਕਲਪਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ ਸੰਚਾਰਿਤ ਕਰਦੇ ਹੋ.
ਤਕਨੀਕੀ ਇੰਟਰਵਿਊਆਂ ਨੂੰ ਸਮਝਣਾ
ਤਕਨੀਕੀ ਇੰਟਰਵਿਊ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮਿੰਗ ਹੁਨਰਾਂ, ਸਮੱਸਿਆ ਹੱਲ ਕਰਨ ਦੀਆਂ ਯੋਗਤਾਵਾਂ, ਐਲਗੋਰਿਦਮਿਕ ਸੋਚ ਅਤੇ ਤਕਨੀਕੀ ਗਿਆਨ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਨ. ਉਨ੍ਹਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਕੋਡਿੰਗ ਚੁਣੌਤੀਆਂ, ਸਿਸਟਮ ਡਿਜ਼ਾਈਨ ਵਿਚਾਰ-ਵਟਾਂਦਰੇ ਅਤੇ ਤਕਨੀਕੀ ਸੰਕਲਪ ਪ੍ਰਸ਼ਨ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ.
ਤਕਨੀਕੀ ਪ੍ਰਸ਼ਨਾਂ ਦੀਆਂ ਕਿਸਮਾਂ:
- ਕੋਡਿੰਗ ਸਮੱਸਿਆਵਾਂ: ਐਲਗੋਰਿਦਮ ਲਾਗੂ ਕਰਨਾ ਅਤੇ ਸਮੱਸਿਆ ਹੱਲ ਕਰਨਾ
- ਡਾਟਾ structureਾਂਚੇ ਦੇ ਪ੍ਰਸ਼ਨ: ਐਰੇ, ਲਿੰਕਡ ਸੂਚੀ, ਰੁੱਖ, ਗ੍ਰਾਫ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ
- ਸਿਸਟਮ ਡਿਜ਼ਾਈਨ: ਸਕੇਲੇਬਲ ਪ੍ਰਣਾਲੀਆਂ ਅਤੇ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨਾ
- ਡਾਟਾਬੇਸ ਪ੍ਰਸ਼ਨ: SQL ਪ੍ਰਸ਼ਨ ਅਤੇ ਡਾਟਾਬੇਸ ਡਿਜ਼ਾਈਨ
- ਡੀਬੱਗਿੰਗ: ਕੋਡ ਦੇ ਮੁੱਦਿਆਂ ਨੂੰ ਲੱਭਣਾ ਅਤੇ ਠੀਕ ਕਰਨਾ
- ਤਕਨੀਕੀ ਸੰਕਲਪ: ਐਲਗੋਰਿਦਮ, ਫਰੇਮਵਰਕ ਅਤੇ ਤਕਨਾਲੋਜੀਆਂ ਦੀ ਵਿਆਖਿਆ ਕਰਨਾ
ਇੰਟਰਵਿਊ ਲੈਣ ਵਾਲੇ ਕੀ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਨ:
- ਸਮੱਸਿਆ ਹੱਲ ਕਰਨ ਦੀ ਪਹੁੰਚ: ਤੁਸੀਂ ਗੁੰਝਲਦਾਰ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਕਿਵੇਂ ਤੋੜਦੇ ਹੋ
- ਕੋਡਿੰਗ ਹੁਨਰ: ਸਾਫ਼, ਕੁਸ਼ਲ ਕੋਡ ਲਿਖਣ ਦੀ ਯੋਗਤਾ
- ਐਲਗੋਰਿਦਮ ਗਿਆਨ: ਡਾਟਾ ਢਾਂਚਿਆਂ ਅਤੇ ਐਲਗੋਰਿਦਮ ਦੀ ਸਮਝ
- ਸੰਚਾਰ: ਤਕਨੀਕੀ ਸੰਕਲਪਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਸਮਝਾਉਣ ਦੀ ਯੋਗਤਾ
- ਕੋਡ ਦੀ ਗੁਣਵੱਤਾ: ਪੜ੍ਹਨਯੋਗ, ਰੱਖਣਯੋਗ ਕੋਡ ਲਿਖਣਾ
ਬੁਨਿਆਦੀ ਡੇਟਾ ਢਾਂਚੇ ਅਤੇ ਐਲਗੋਰਿਦਮ
ਐਰੇ ਅਤੇ ਸਟਰਿੰਗਜ਼
ਆਮ ਸਮੱਸਿਆਵਾਂ:
1. ਦੋ ਸਮ
ਸਮੱਸਿਆ: ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਲੜੀ 'nums' ਅਤੇ ਇੱਕ ਪੂਰਨ ਅੰਕ 'ਟੀਚਾ' ਦੇ ਮੱਦੇਨਜ਼ਰ, ਦੋ ਨੰਬਰਾਂ ਦੇ ਸੂਚਕ ਅੰਕ ਵਾਪਸ ਕਰੋ ਜੋ 'ਟੀਚਾ' ਨੂੰ ਜੋੜਦੇ ਹਨ.
ਹੱਲ:
''ਪਾਈਥਨ
def twosum(nums, target):
# ਵੈਲਿਊ -> ਇੰਡੈਕਸ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਹੈਸ਼ ਮੈਪ ਬਣਾਓ
nummap = {}
ਮੈਂ ਲਈ, ਗਿਣਤੀ(ਅੰਕ) ਵਿੱਚ ਅੰਕ:
ਪੂਰਕ = ਟੀਚਾ - ਅੰਕ
ਜੇ nummap ਵਿੱਚ ਪੂਰਕ ਹੈ:
ਵਾਪਸੀ [nummap[ਪੂਰਕ], i]
nummap[num] = i
ਵਾਪਸੀ []
ਸਮਾਂ: O (n), ਸਪੇਸ: O (min(m, n)) ਜਿੱਥੇ m ਚਾਰਸੈੱਟ ਦਾ ਆਕਾਰ ਹੈ
ਵਿਆਖਿਆ: ਵਿਲੱਖਣ ਅੱਖਰਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਸੈੱਟ ਦੇ ਨਾਲ ਸਲਾਈਡਿੰਗ ਵਿੰਡੋ ਤਕਨੀਕ.
ਲਿੰਕ ਕੀਤੀਆਂ ਸੂਚੀਆਂ
1. ਰਿਵਰਸ ਲਿੰਕਡ ਸੂਚੀ
ਸਮੱਸਿਆ: ਇੱਕ ਸਿੰਗਲ ਲਿੰਕ ਸੂਚੀ ਨੂੰ ਉਲਟਾਓ.
ਹੱਲ:
''ਪਾਈਥਨ
ਡੈਫ reverselist (ਸਿਰ):
ਪਿਛਲਾ = ਕੋਈ ਨਹੀਂ
ਮੌਜੂਦਾ = ਸਿਰ
ਜਦੋਂ ਕਿ ਮੌਜੂਦਾ:
nexttemp = current.next
current.next = ਪਿਛਲਾ
ਪਿਛਲਾ = ਮੌਜੂਦਾ
ਮੌਜੂਦਾ = nexttemp
ਵਾਪਸੀ ਪਿਛਲਾ
ਸਮਾਂ: ਓ (ਐਨ), ਸਪੇਸ: ਓ (1)
ਵਿਆਖਿਆ: ਹੌਲੀ ਅਤੇ ਤੇਜ਼ ਪੁਆਇੰਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਫਲਾਇਡ ਦਾ ਚੱਕਰ ਖੋਜ ਐਲਗੋਰਿਦਮ.
ਰੁੱਖ ਅਤੇ ਬਾਈਨਰੀ ਖੋਜ ਰੁੱਖ
1. ਬਾਈਨਰੀ ਟ੍ਰੀ ਇਨਆਰਡਰ ਟ੍ਰੈਵਰਸਲ
ਸਮੱਸਿਆ: ਬਾਈਨਰੀ ਟ੍ਰੀ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਵਾਪਸ ਜਾਓ.
ਹੱਲ:
''ਪਾਈਥਨ
ਡੈਫ inordertraversal(ਰੂਟ):
ਨਤੀਜਾ = []
ਸਟੈਕ = []
ਕਰੰਟ = ਰੂਟ
ਜਦੋਂ ਕਿ ਕਰੰਟ ਜਾਂ ਸਟੈਕ:
ਜਦੋਂ ਕਿ ਮੌਜੂਦਾ:
ਸਟੈਕ.ਅਪੈਂਡ (ਮੌਜੂਦਾ)
ਮੌਜੂਦਾ = ਮੌਜੂਦਾ.ਖੱਬੇ
ਮੌਜੂਦਾ = Stack.pop()
result.append (current.val)
ਮੌਜੂਦਾ = ਕਰੰਟ.ਰਾਈਟ
ਵਾਪਸੀ ਦਾ ਨਤੀਜਾ
ਸਮਾਂ: ਓ (ਐਨ), ਸਪੇਸ: ਓ (ਐਚ)
ਵਿਆਖਿਆ: ਹਰੇਕ ਸਬਟ੍ਰੀ ਲਈ ਸੀਮਾਵਾਂ ਦੀ ਜਾਂਚ ਦੇ ਨਾਲ ਆਵਰਤੀ ਪ੍ਰਮਾਣਿਕਤਾ.
ਡਾਇਨਾਮਿਕ ਪ੍ਰੋਗਰਾਮਿੰਗ
1. ਪੌੜੀਆਂ ਚੜ੍ਹਨਾ
ਸਮੱਸਿਆ: ਪੌੜੀਆਂ ਚੜ੍ਹਨ ਦੇ ਕਈ ਤਰੀਕੇ ਲੱਭੋ (ਇੱਕ ਸਮੇਂ 'ਤੇ 1 ਜਾਂ 2 ਕਦਮ)।
ਹੱਲ:
''ਪਾਈਥਨ
ਡੈਫ climbstairs (ਐਨ):
ਜੇ n = tokensneeded:
self.tokens -= tokensneeded
ਵਾਪਸੀ ਸੱਚੀ
ਵਾਪਸੀ ਝੂਠੀ
ਵਿਕਲਪ:
''' SQL
ਤਨਖਾਹ ਨੂੰ ਦੂਜੀ ਸਭ ਤੋਂ ਉੱਚੀ ਤਨਖਾਹ ਵਜੋਂ ਚੁਣੋ
ਕਰਮਚਾਰੀ ਤੋਂ
ਤਨਖਾਹ DESC ਦੁਆਰਾ ਆਰਡਰ
ਸੀਮਾ 1 ਆਫਸੈੱਟ 1
3. ਨੌਵੀਂ ਸਭ ਤੋਂ ਵੱਧ ਤਨਖਾਹ
ਸਮੱਸਿਆ: ਨੌਵੀਂ ਸਭ ਤੋਂ ਵੱਧ ਤਨਖਾਹ ਲੱਭੋ।
ਹੱਲ:
''' SQL
ਫੰਕਸ਼ਨ ਬਣਾਓ GETNthHighestSalary(N INT) RETURNS INT
ਅਰੰਭ ਕਰੋ
ਨਤੀਜਾ INT ਘੋਸ਼ਿਤ ਕਰੋ;
ਸੈੱਟ ਨਤੀਜਾ = ਮਨਸੂਖ;
ਨਤੀਜੇ ਵਿੱਚ ਤਨਖਾਹ ਦੀ ਚੋਣ ਕਰੋ
ਤੋਂ (
ਤਨਖਾਹ, DENSERANK() ਓਵਰ (ਸੈਲਰੀ ਡੀਈਐਸਸੀ ਦੁਆਰਾ ਆਰਡਰ) ਨੂੰ ਆਰਐਨਕੇ ਵਜੋਂ ਚੁਣੋ
ਕਰਮਚਾਰੀ ਤੋਂ
) ਦਰਜਾ ਦਿੱਤਾ ਗਿਆ
ਜਿੱਥੇ rnk = N
ਸੀਮਾ 1;
ਵਾਪਸੀ ਦਾ ਨਤੀਜਾ;
ਅੰਤ
ਮੁੱਖ ਸੰਕਲਪ: ਐਨਕੈਪਸੁਲੇਸ਼ਨ, ਵਿਰਾਸਤ, ਪੌਲੀਮੋਰਫਿਜ਼ਮ, ਡਿਜ਼ਾਈਨ ਪੈਟਰਨ.
2. ਇੱਕ ਵੈਂਡਿੰਗ ਮਸ਼ੀਨ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰੋ
ਜ਼ਰੂਰਤਾਂ:
• ਸਿੱਕੇ/ਬਿੱਲ ਸਵੀਕਾਰ ਕਰੋ
• ਉਤਪਾਦਾਂ ਦੀ ਵੰਡ
- ਨਾਕਾਫ਼ੀ ਫੰਡਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ
- ਤਬਦੀਲੀ ਵਾਪਸ ਕਰੋ
- ਸਟਾਕ ਪ੍ਰਬੰਧਨ
ਡਿਜ਼ਾਈਨ ਪਹੁੰਚ:
''ਪਾਈਥਨ
ਕਲਾਸ ਵੈਂਡਿੰਗ ਮਸ਼ੀਨ:
ਡੈਫ init (ਸਵੈ):
self.products = {} # productid -> (ਨਾਮ, ਕੀਮਤ, ਮਾਤਰਾ)
ਸਵੈ-ਸੰਤੁਲਨ = 0
def insertmoney(ਸਵੈ, ਰਕਮ):
Self.balance += ਰਕਮ
ਡੈਫ selectproduct(ਸਵੈ, productid):
ਜੇ productid ਸਵੈ-ਉਤਪਾਦਾਂ ਵਿੱਚ ਨਹੀਂ ਹਨ:
"ਉਤਪਾਦ ਨਹੀਂ ਲੱਭਿਆ" ਵਾਪਸ ਕਰੋ
ਨਾਮ, ਕੀਮਤ, ਮਾਤਰਾ = ਸਵੈ-ਉਤਪਾਦ[productid]
ਜੇ ਮਾਤਰਾ == 0:
"ਸਟਾਕ ਤੋਂ ਬਾਹਰ" ਵਾਪਸ ਕਰੋ
ਜੇ ਸਵੈ-ਸੰਤੁਲਨ
