["   \n  \n ('ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?') ", 'ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?', " ['ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?', 'ਮੇਰਾ ਨਾਮ ਸਹਾਇਕ ਹੈ। ਮੈਂ ਇੱਕ ਆਰਟੀਫਿਸ਼ਲ ਇੰਟੈਲੀਜੈਂਸ ਹਾਂ ਜੋ ਤੁਹਾਡੇ ਵਰਗੇ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸਹਾਇਤਾ ਅਤੇ ਸੰਚਾਰ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ।', 'ਇੱਕ ਲਿਖੋ।ਪਾਈਥਨ ਵਿੱਚ ਕੁਇੱਕਸੋਰਟ ਕੋਡ '] ", 'ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?', ' [\'ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?\', \'ਮੇਰਾ ਨਾਮ ਸਹਾਇਕ ਹੈ। ਮੈਂ ਇੱਕ ਆਰਟੀਫਿਸ਼ਲ ਇੰਟੈਲੀਜੈਂਸ ਹਾਂ ਜੋ ਤੁਹਾਡੇ ਵਰਗੇ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸਹਾਇਤਾ ਅਤੇ ਸੰਚਾਰ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ।\', \'ਇੱਕ ਲਿਖੋ।ਪਾਈਥਨ ਵਿੱਚ ਕੁਇੱਕਸੌਰਟ ਕੋਡ \', "ਯਕੀਨਨ, ਇੱਥੇ ਪਾਈਥਨ ਵਿੱਚ ਕੁਇੱਕਸੌਰਟ ਐਲਗੋਰਿਦਮ ਦਾ ਇੱਕ ਬੁਨਿਆਦੀ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ \\ndef ਕੁਇੱਕਸੌਰਟ (arr, ਲੋ, ਹਾਈ): \\nਜੇਕਰ ਘੱਟ <ਉੱਚਃ \\n ਪਿਵੋਟ _ ਇੰਡੈਕਸ = ਪਾਰਟੀਸ਼ਨ (arr, ਘੱਟ, ਉੱਚ) \\n ਕੁਇੱਕਸੋਰਟ (arr, ਘੱਟ, ਪਿਵੋਟ _ ਇੰਡੈਕਸ) \\n ਕੁਇੱਕਸੋਰਟ (arr, ਪਿਵੋਟ _ ਇੰਡੈਕਸ + 1, ਉੱਚ) \\n\\ndefਪਾਰਟੀਸ਼ਨ (arr, ਨੀਵਾਂ, ਉੱਚਾ): \\n ਪਾਇਵਟ = arr [ਨੀਵਾਂ] \\n ਖੱਬਾ = ਨੀਵਾਂ + 1\\n ਸੱਜਾ = ਉੱਚਾ \\n ਕੀਤਾ = ਗਲਤ \\n ਜਦੋਂ ਕਿ ਨਹੀਂ ਕੀਤਾ ਗਿਆਃ \\n ਜਦੋਂ ਕਿ ਖੱਬਾ <= ਸੱਜਾ ਅਤੇ arr [ਖੱਬਾ] <=ਧੁਰੀਃ \\n ਖੱਬਾ = ਖੱਬਾ + 1\\n ਜਦੋਂ ਕਿ arr [ਸੱਜਾ]> = ਧੁਰੀ ਅਤੇ ਸੱਜਾ> = ਖੱਬਾਃ \\n ਸੱਜਾ = ਸੱਜਾ-1\\n ਜੇਕਰ ਸੱਜਾ <ਖੱਬਾਃ \\n ਕੀਤਾ = ਸੱਚਾ \\n ਨਹੀਂ ਤਾਂਃ \\n arr [ਖੱਬਾ],arr [ਸੱਜੇ] = arr [ਸੱਜੇ], arr [ਖੱਬੇ] \\n arr [ਘੱਟ], arr [ਸੱਜੇ] = arr [ਸੱਜੇ], arr [ਘੱਟ] \\n ਵਾਪਸ ਕਰੋ ਸੱਜੇ \\n\\narr = [12,4,5,6,7,3,1,15] \\nquiksort (arr, 0,ਲੇਨ (arr)-1) \\nਪ੍ਰਿੰਟ (arr) \\n "\\n" ਇਹ ਕੋਡ ਇੱਕ ਐਰੇ, ਇੱਕ ਘੱਟ ਇੰਡੈਕਸ (ਆਮ ਤੌਰ ਉੱਤੇ 0), ਅਤੇ ਇੱਕ ਉੱਚ ਇੰਡੈਕਸ (ਆਮ ਤੌਰ ਉੱਤੇ ਐਰੇ ਦਾ ਆਖਰੀ ਇੰਡੈਕਸ) ਵਿੱਚ ਲੈਂਦਾ ਹੈ, ਅਤੇਐਰੇ ਉੱਤੇ ਇੱਕ ਕੁਇੱਕਸੋਰਟ ਕਰਦਾ ਹੈ। \'ਪਾਰਟੀਸ਼ਨ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਇੱਕ ਚੁਣੇ ਹੋਏ ਪਾਈਵਟ ਤੱਤ ਦੇ ਦੁਆਲੇ ਐਰੇ ਨੂੰ ਵੰਡਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਫਿਰ \'ਕੁਇੱਕਸੋਰਟ\'ਫੰਕਸ਼ਨ ਨੂੰ ਐਰੇ ਦੇ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਅੱਧਿਆਂ ਉੱਤੇ ਆਵਰਤੀ ਤੌਰ ਉੱਤੇ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਪੂਰੀ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ। ਅੰਤ ਵਿੱਚ, ਕ੍ਰਮਬੱਧ ਐਰੇ ਪ੍ਰਿੰਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਸੀ + + ਵਿੱਚ ਇੱਕ ਤੇਜ਼ ਪਾਵ ਐਲਗੋਰਿਦਮ ਲਿਖੋ\'] ', 'ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?', ' [\'ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?\', \'ਮੇਰਾ ਨਾਮ ਸਹਾਇਕ ਹੈ। ਮੈਂ ਇੱਕ ਆਰਟੀਫਿਸ਼ਲ ਇੰਟੈਲੀਜੈਂਸ ਹਾਂ ਜੋ ਤੁਹਾਡੇ ਵਰਗੇ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸਹਾਇਤਾ ਅਤੇ ਸੰਚਾਰ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ।\', \'ਇੱਕ ਲਿਖੋ।ਪਾਈਥਨ ਵਿੱਚ ਕੁਇੱਕਸੌਰਟ ਕੋਡ \', "ਯਕੀਨਨ, ਇੱਥੇ ਪਾਈਥਨ ਵਿੱਚ ਕੁਇੱਕਸੌਰਟ ਐਲਗੋਰਿਦਮ ਦਾ ਇੱਕ ਬੁਨਿਆਦੀ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ \\ndef ਕੁਇੱਕਸੌਰਟ (arr, ਲੋ, ਹਾਈ): \\nਜੇਕਰ ਘੱਟ <ਉੱਚਃ \\n ਪਿਵੋਟ _ ਇੰਡੈਕਸ = ਪਾਰਟੀਸ਼ਨ (arr, ਘੱਟ, ਉੱਚ) \\n ਕੁਇੱਕਸੋਰਟ (arr, ਘੱਟ, ਪਿਵੋਟ _ ਇੰਡੈਕਸ) \\n ਕੁਇੱਕਸੋਰਟ (arr, ਪਿਵੋਟ _ ਇੰਡੈਕਸ + 1, ਉੱਚ) \\n\\ndefਪਾਰਟੀਸ਼ਨ (arr, ਨੀਵਾਂ, ਉੱਚਾ): \\n ਪਾਇਵਟ = arr [ਨੀਵਾਂ] \\n ਖੱਬਾ = ਨੀਵਾਂ + 1\\n ਸੱਜਾ = ਉੱਚਾ \\n ਕੀਤਾ = ਗਲਤ \\n ਜਦੋਂ ਕਿ ਨਹੀਂ ਕੀਤਾ ਗਿਆਃ \\n ਜਦੋਂ ਕਿ ਖੱਬਾ <= ਸੱਜਾ ਅਤੇ arr [ਖੱਬਾ] <=ਧੁਰੀਃ \\n ਖੱਬਾ = ਖੱਬਾ + 1\\n ਜਦੋਂ ਕਿ arr [ਸੱਜਾ]> = ਧੁਰੀ ਅਤੇ ਸੱਜਾ> = ਖੱਬਾਃ \\n ਸੱਜਾ = ਸੱਜਾ-1\\n ਜੇਕਰ ਸੱਜਾ <ਖੱਬਾਃ \\n ਕੀਤਾ = ਸੱਚਾ \\n ਨਹੀਂ ਤਾਂਃ \\n arr [ਖੱਬਾ],arr [ਸੱਜੇ] = arr [ਸੱਜੇ], arr [ਖੱਬੇ] \\n arr [ਘੱਟ], arr [ਸੱਜੇ] = arr [ਸੱਜੇ], arr [ਘੱਟ] \\n ਵਾਪਸ ਕਰੋ ਸੱਜੇ \\n\\narr = [12,4,5,6,7,3,1,15] \\nquiksort (arr, 0,ਲੇਨ (arr)-1) \\nਪ੍ਰਿੰਟ (arr) \\n "\\n" ਇਹ ਕੋਡ ਇੱਕ ਐਰੇ, ਇੱਕ ਘੱਟ ਇੰਡੈਕਸ (ਆਮ ਤੌਰ ਉੱਤੇ 0), ਅਤੇ ਇੱਕ ਉੱਚ ਇੰਡੈਕਸ (ਆਮ ਤੌਰ ਉੱਤੇ ਐਰੇ ਦਾ ਆਖਰੀ ਇੰਡੈਕਸ) ਵਿੱਚ ਲੈਂਦਾ ਹੈ, ਅਤੇਐਰੇ ਉੱਤੇ ਇੱਕ ਕੁਇੱਕਸੋਰਟ ਕਰਦਾ ਹੈ। \'ਪਾਰਟੀਸ਼ਨ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਇੱਕ ਚੁਣੇ ਹੋਏ ਪਾਈਵਟ ਤੱਤ ਦੇ ਦੁਆਲੇ ਐਰੇ ਨੂੰ ਵੰਡਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਫਿਰ \'ਕੁਇੱਕਸੋਰਟ\'ਫੰਕਸ਼ਨ ਨੂੰ ਐਰੇ ਦੇ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਅੱਧਿਆਂ ਉੱਤੇ ਆਵਰਤੀ ਤੌਰ ਉੱਤੇ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਪੂਰੀ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ। ਅੰਤ ਵਿੱਚ, ਕ੍ਰਮਬੱਧ ਐਰੇ ਪ੍ਰਿੰਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'c + + ਵਿੱਚ ਇੱਕ ਕੁਇੱਕ ਪਾਵ ਐਲਗੋਰਿਦਮ ਲਿਖੋ\', \'ਯਕੀਨਨ, ਇੱਥੇ C + + ਵਿੱਚ ਕੁਇੱਕ ਪਾਵ ਐਲਗੋਰਿਦਮ ਦਾ ਇੱਕ ਬੁਨਿਆਦੀ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n\' cpp\\ n#include<ਬਿੱਟਸ/ਐਸ. ਟੀ. ਡੀ. ਸੀ. + +. ਐਚ.> \\ਨਯੂਸਿੰਗ ਨੇਮਸਪੇਸ ਐਸ. ਟੀ. ਡੀ.; \\n\\nint ਕੁਇੱਕਪੌ (ਇੰਟ ਬੇਸ, ਇੰਟ ਐਕਸਪੋਨੈਂਟ, ਇੰਟ ਮੋਡੀਊਲੋ) {\\n ਇੰਟ ਰੀਸ = 1; \\n ਜਦੋਂ ਕਿ (ਐਕਸਪੋਨੈਂਟ> 0) {\\n ਜੇਕਰ (ਐਕਸਪੋਨੈਂਟ% 2)= = 1) {\\n ਰੇਸ = (ਰੇਸ * ਬੇਸ)% ਮੋਡੀਊਲੋ; \\n} \\n ਬੇਸ = (ਬੇਸ * ਬੇਸ)% ਮੋਡੀਊਲੋ; \\n ਐਕਸਪੋਨੈਂਟ/= 2; \\n} \\n ਰਿਟਰਨ ਰੇਸ; \\n} \\n\\nint ਮੇਨ () {\\n ਇੰਟ ਬੇਸ = 5; \\nਇੰਟ ਐਕਸਪੋਨੈਂਟ = 3; \\n ਇੰਟ ਮੋਡੀਊਲੋ = 10; \\n ਇੰਟ ਨਤੀਜਾ = ਤੇਜ਼ (ਅਧਾਰ, ਐਕਸਪੋਨੈਂਟ, ਮੋਡੀਊਲੋ); \\n cout <<"ਨਤੀਜਾਃ" <<ਨਤੀਜਾ <<ਅੰਤ; \\n ਵਾਪਸੀ0; \\n} \\n "\'\\n\\n ਇਹ ਕੋਡ ਤਿੰਨ ਪੂਰਨ ਅੰਕਾਂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈਃ\' ਅਧਾਰ \',\' ਐਕਸਪੋਨੈਂਟ \'ਅਤੇ\' ਮਾਡੁਲੋ \'।\' ਕੁਇੱਕਪੋ \'ਫੰਕਸ਼ਨ\' ਅਧਾਰ \'ਦੇ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ।\'ਐਕਸਪੋਨੈਂਟ\' ਮੋਡੀਊਲੋ \'ਮੋਡੀਊਲੋ\' ਦੀ ਸ਼ਕਤੀ ਤੱਕ ਉਭਾਰਿਆ ਜਾਂਦਾ ਹੈ। ਫੰਕਸ਼ਨ \'ਬੇਸ\' ਨੂੰ \'ਬੇਸ\' ਨਾਲ ਵਾਰ-ਵਾਰ ਗੁਣਾ ਕਰਨ ਅਤੇ \'ਐਕਸਪੋਨੈਂਟ\' ਨੂੰ 1 ਨਾਲ ਘਟਾਉਣ ਲਈ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਤੱਕ \'ਐਕਸਪੋਨੈਂਟ\' 0 ਨਹੀਂ ਹੋ ਜਾਂਦਾ। ਫਿਰ ਨਤੀਜਾ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ। \'ਮੁੱਖ\' ਫੰਕਸ਼ਨ ਵਿੱਚ, \'ਅਧਾਰ\', \'ਐਕਸਪੋਨੈਂਟ\' ਅਤੇ \'ਮੋਡੀਊਲੋ\' ਦੇ ਮੁੱਲ ਸੈੱਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ\'ਕੁਇੱਕਪੋ\' ਫੰਕਸ਼ਨ ਨੂੰ ਨਤੀਜੇ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਨਤੀਜਾ ਫਿਰ ਕੰਸੋਲ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \',\' ਇਸ ਕੋਡ ਨੂੰ ਪਾਈਥਨ ਵਿੱਚ ਬਦਲੋ \'] ', 'ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?', ' [\'ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?\', \'ਮੇਰਾ ਨਾਮ ਸਹਾਇਕ ਹੈ। ਮੈਂ ਇੱਕ ਆਰਟੀਫਿਸ਼ਲ ਇੰਟੈਲੀਜੈਂਸ ਹਾਂ ਜੋ ਤੁਹਾਡੇ ਵਰਗੇ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸਹਾਇਤਾ ਅਤੇ ਸੰਚਾਰ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ।\', \'ਇੱਕ ਲਿਖੋ।ਪਾਈਥਨ ਵਿੱਚ ਕੁਇੱਕਸੌਰਟ ਕੋਡ \', "ਯਕੀਨਨ, ਇੱਥੇ ਪਾਈਥਨ ਵਿੱਚ ਕੁਇੱਕਸੌਰਟ ਐਲਗੋਰਿਦਮ ਦਾ ਇੱਕ ਬੁਨਿਆਦੀ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n"\' ਪਾਈਥਨ \\ndef ਕੁਇੱਕਸੌਰਟ (arr, ਲੋ, ਹਾਈ): \\nਜੇਕਰ ਘੱਟ <ਉੱਚਃ \\n ਪਿਵੋਟ _ ਇੰਡੈਕਸ = ਪਾਰਟੀਸ਼ਨ (arr, ਘੱਟ, ਉੱਚ) \\n ਕੁਇੱਕਸੋਰਟ (arr, ਘੱਟ, ਪਿਵੋਟ _ ਇੰਡੈਕਸ) \\n ਕੁਇੱਕਸੋਰਟ (arr, ਪਿਵੋਟ _ ਇੰਡੈਕਸ + 1, ਉੱਚ) \\n\\ndefਪਾਰਟੀਸ਼ਨ (arr, ਨੀਵਾਂ, ਉੱਚਾ): \\n ਪਾਇਵਟ = arr [ਨੀਵਾਂ] \\n ਖੱਬਾ = ਨੀਵਾਂ + 1\\n ਸੱਜਾ = ਉੱਚਾ \\n ਕੀਤਾ = ਗਲਤ \\n ਜਦੋਂ ਕਿ ਨਹੀਂ ਕੀਤਾ ਗਿਆਃ \\n ਜਦੋਂ ਕਿ ਖੱਬਾ <= ਸੱਜਾ ਅਤੇ arr [ਖੱਬਾ] <=ਧੁਰੀਃ \\n ਖੱਬਾ = ਖੱਬਾ + 1\\n ਜਦੋਂ ਕਿ arr [ਸੱਜਾ]> = ਧੁਰੀ ਅਤੇ ਸੱਜਾ> = ਖੱਬਾਃ \\n ਸੱਜਾ = ਸੱਜਾ-1\\n ਜੇਕਰ ਸੱਜਾ <ਖੱਬਾਃ \\n ਕੀਤਾ = ਸੱਚਾ \\n ਨਹੀਂ ਤਾਂਃ \\n arr [ਖੱਬਾ],arr [ਸੱਜੇ] = arr [ਸੱਜੇ], arr [ਖੱਬੇ] \\n arr [ਘੱਟ], arr [ਸੱਜੇ] = arr [ਸੱਜੇ], arr [ਘੱਟ] \\n ਵਾਪਸ ਕਰੋ ਸੱਜੇ \\n\\narr = [12,4,5,6,7,3,1,15] \\nquiksort (arr, 0,ਲੇਨ (arr)-1) \\nਪ੍ਰਿੰਟ (arr) \\n "\\n" ਇਹ ਕੋਡ ਇੱਕ ਐਰੇ, ਇੱਕ ਘੱਟ ਇੰਡੈਕਸ (ਆਮ ਤੌਰ ਉੱਤੇ 0), ਅਤੇ ਇੱਕ ਉੱਚ ਇੰਡੈਕਸ (ਆਮ ਤੌਰ ਉੱਤੇ ਐਰੇ ਦਾ ਆਖਰੀ ਇੰਡੈਕਸ) ਵਿੱਚ ਲੈਂਦਾ ਹੈ, ਅਤੇਐਰੇ ਉੱਤੇ ਇੱਕ ਕੁਇੱਕਸੋਰਟ ਕਰਦਾ ਹੈ। \'ਪਾਰਟੀਸ਼ਨ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਇੱਕ ਚੁਣੇ ਹੋਏ ਪਾਈਵਟ ਤੱਤ ਦੇ ਦੁਆਲੇ ਐਰੇ ਨੂੰ ਵੰਡਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਫਿਰ \'ਕੁਇੱਕਸੋਰਟ\'ਫੰਕਸ਼ਨ ਨੂੰ ਐਰੇ ਦੇ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਅੱਧਿਆਂ ਉੱਤੇ ਆਵਰਤੀ ਤੌਰ ਉੱਤੇ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਪੂਰੀ ਐਰੇ ਨੂੰ ਕ੍ਰਮਬੱਧ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ। ਅੰਤ ਵਿੱਚ, ਕ੍ਰਮਬੱਧ ਐਰੇ ਪ੍ਰਿੰਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'c + + ਵਿੱਚ ਇੱਕ ਕੁਇੱਕ ਪਾਵ ਐਲਗੋਰਿਦਮ ਲਿਖੋ\', \'ਯਕੀਨਨ, ਇੱਥੇ C + + ਵਿੱਚ ਕੁਇੱਕ ਪਾਵ ਐਲਗੋਰਿਦਮ ਦਾ ਇੱਕ ਬੁਨਿਆਦੀ ਲਾਗੂਕਰਨ ਹੈਃ \\n\\n\' cpp\\ n#include<ਬਿੱਟਸ/ਐਸ. ਟੀ. ਡੀ. ਸੀ. + +. ਐਚ.> \\ਨਯੂਸਿੰਗ ਨੇਮਸਪੇਸ ਐਸ. ਟੀ. ਡੀ.; \\n\\nint ਕੁਇੱਕਪੌ (ਇੰਟ ਬੇਸ, ਇੰਟ ਐਕਸਪੋਨੈਂਟ, ਇੰਟ ਮੋਡੀਊਲੋ) {\\n ਇੰਟ ਰੀਸ = 1; \\n ਜਦੋਂ ਕਿ (ਐਕਸਪੋਨੈਂਟ> 0) {\\n ਜੇਕਰ (ਐਕਸਪੋਨੈਂਟ% 2)= = 1) {\\n ਰੇਸ = (ਰੇਸ * ਬੇਸ)% ਮੋਡੀਊਲੋ; \\n} \\n ਬੇਸ = (ਬੇਸ * ਬੇਸ)% ਮੋਡੀਊਲੋ; \\n ਐਕਸਪੋਨੈਂਟ/= 2; \\n} \\n ਰਿਟਰਨ ਰੇਸ; \\n} \\n\\nint ਮੇਨ () {\\n ਇੰਟ ਬੇਸ = 5; \\nਇੰਟ ਐਕਸਪੋਨੈਂਟ = 3; \\n ਇੰਟ ਮੋਡੀਊਲੋ = 10; \\n ਇੰਟ ਨਤੀਜਾ = ਤੇਜ਼ (ਅਧਾਰ, ਐਕਸਪੋਨੈਂਟ, ਮੋਡੀਊਲੋ); \\n cout <<"ਨਤੀਜਾਃ" <<ਨਤੀਜਾ <<ਅੰਤ; \\n ਵਾਪਸੀ0; \\n} \\n "\'\\n\\n ਇਹ ਕੋਡ ਤਿੰਨ ਪੂਰਨ ਅੰਕਾਂ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦਾ ਹੈਃ\' ਅਧਾਰ \',\' ਐਕਸਪੋਨੈਂਟ \'ਅਤੇ\' ਮਾਡੁਲੋ \'।\' ਕੁਇੱਕਪੋ \'ਫੰਕਸ਼ਨ\' ਅਧਾਰ \'ਦੇ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ।\'ਐਕਸਪੋਨੈਂਟ\' ਮੋਡੀਊਲੋ \'ਮੋਡੀਊਲੋ\' ਦੀ ਸ਼ਕਤੀ ਤੱਕ ਉਭਾਰਿਆ ਜਾਂਦਾ ਹੈ। ਫੰਕਸ਼ਨ \'ਬੇਸ\' ਨੂੰ \'ਬੇਸ\' ਨਾਲ ਵਾਰ-ਵਾਰ ਗੁਣਾ ਕਰਨ ਅਤੇ \'ਐਕਸਪੋਨੈਂਟ\' ਨੂੰ 1 ਨਾਲ ਘਟਾਉਣ ਲਈ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਤੱਕ \'ਐਕਸਪੋਨੈਂਟ\' 0 ਨਹੀਂ ਹੋ ਜਾਂਦਾ। ਫਿਰ ਨਤੀਜਾ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ। \'ਮੁੱਖ\' ਫੰਕਸ਼ਨ ਵਿੱਚ, \'ਅਧਾਰ\', \'ਐਕਸਪੋਨੈਂਟ\' ਅਤੇ \'ਮੋਡੀਊਲੋ\' ਦੇ ਮੁੱਲ ਸੈੱਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ\'ਕੁਇੱਕਪੋ\' ਫੰਕਸ਼ਨ ਨੂੰ ਨਤੀਜੇ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਨਤੀਜਾ ਫਿਰ ਕੰਸੋਲ ਉੱਤੇ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \',\' ਇਸ ਕੋਡ ਨੂੰ ਪਾਈਥਨ ਵਿੱਚ ਬਦਲੋ \',\' ਯਕੀਨਨ, ਇੱਥੇ ਹੈਪਾਈਥਨ ਵਿੱਚ ਕੁਇੱਕਪੌ ਐਲਗੋਰਿਦਮ ਦਾ ਬਰਾਬਰ ਲਾਗੂਕਰਨਃ \\n\\n "\'cpp\\ n#include <ਬਿੱਟਸ/ਐਸ. ਟੀ. ਡੀ. ਸੀ. + +. h> \\nusing ਨੇਮਸਪੇਸ ਐਸ. ਟੀ. ਡੀ.; \\n\\nint ਕੁਇੱਕਪੌ (ਇੰਟ ਬੇਸ, ਇੰਟ)ਐਕਸਪੋਨੈਂਟ, ਇੰਟ ਮੋਡੀਊਲੋ) {\\n ਇੰਟ ਰੇਸ = 1; \\n ਜਦੋਂ ਕਿ (ਐਕਸਪੋਨੈਂਟ> 0) {\\n ਜੇਕਰ (ਐਕਸਪੋਨੈਂਟ% 2 = = 1): \\n ਰੇਸ = (ਰੇਸ * ਬੇਸ)% ਮੋਡੀਊਲੋ\\n ਬੇਸ = (ਬੇਸ * ਬੇਸ)%ਮੋਡੀਊਲੋ \\n ਐਕਸਪੋਨੈਂਟ/= 2\\n} \\n ਰਿਟਰਨ ਰੀਸ\\ਨ} \\ਨ\\ਨਿੰਟ ਮੇਨ () {\\ਨ ਇੰਟ ਬੇਸ = 5; \\ਨ ਇੰਟ ਐਕਸਪੋਨੈਂਟ = 3; \\ਨ ਇੰਟ ਮੋਡੀਊਲੋ = 10; \\ਨ ਇੰਟ ਨਤੀਜਾ = ਕੁਇਕਪੋ (ਬੇਸ,ਐਕਸਪੋਨੈਂਟ, ਮੋਡੀਊਲੋ); \\n ਪ੍ਰਿੰਟ ("ਨਤੀਜਾਃ", ਨਤੀਜਾ) \\n ਰਿਟਰਨ 0\\n} \\n \'\\n\\n ਇਹ ਕੋਡ ਅਸਲ C + + ਲਾਗੂ ਕਰਨ ਦੇ ਬਹੁਤ ਸਮਾਨ ਹੈ, ਸਿਰਫਫਰਕ ਪਾਈਥਨ ਸੰਟੈਕਸ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਹੈ। \'ਕੁਇੱਕਪੋ\' ਫੰਕਸ਼ਨ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਵੇਂ ਕਿ C + + ਲਾਗੂ ਕਰਨ ਵਿੱਚ, ਅਤੇ\'ਮੁੱਖ\' ਫੰਕਸ਼ਨ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਿਰਫ਼ \'ਪ੍ਰਿੰਟ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਨਾਲ ਨਤੀਜਾ ਨਿਕਲਦਾ ਹੈ। ਬਾਕੀ ਕੋਡ ਹੈ\',\' \'ਉੱਪਰ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਪਾਈਥਨ ਭਾਸ਼ਾ ਵਿੱਚ ਬਦਲੋ\'] ', 'ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ? \n ']