ਤੁਰੰਤ ਕਿਸੇ ਵੀ ਸਟਰਿੰਗ ਨੂੰ ਉਲਟਣ ਲਈ ਮੁਫਤ ਆਨਲਾਈਨ ਟੈਕਸਟ ਇਨਵਰਟਰ ਟੂਲ। ਅੱਖਰ ਪਲਟੋ, ਪੈਲਿੰਡਰੋਮ ਦੀ ਜਾਂਚ ਕਰੋ, ਅਤੇ ਉਲਟਾ ਟੈਕਸਟ ਬਣਾਓ। ਯੂਨੀਕੋਡ, ਈਮੋਜੀ ਅਤੇ ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।
ਹੇਠਾਂ ਕੋਈ ਵੀ ਟੈਕਸਟ ਦਾਖਲ ਕਰੋ ਜਾਂ ਪੇਸਟ ਕਰੋ ਤਾਂ ਤੁਰੰਤ ਅੱਖਰਾਂ ਦਾ ਕ੍ਰਮ ਉਲਟ ਜਾਵੇਗਾ। ਟਾਈਪ ਕਰਦੇ ਸਮੇਂ ਨਤੀਜੇ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਦੇਖੋ।
ਇੱਕ ਟੈਕਸਟ ਇਨਵਰਟਰ (ਜਿਸਨੂੰ ਉਲਟਾ ਟੈਕਸਟ ਟੂਲ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਤੁਹਾਡੇ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਕ੍ਰਮ ਉਲਟ ਦਿੰਦਾ ਹੈ—"Hello World" ਨੂੰ "dlroW olleH" ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਇਹ ਪੈਲਿੰਡਰੋਮ ਜਾਂਚ ਤੋਂ ਲੈ ਕੇ ਡਿਜ਼ਾਈਨ ਕੰਮ ਲਈ ਦਰਪਣ ਟੈਕਸਟ ਬਣਾਉਣ ਤੱਕ ਬਹੁਤ ਉਪਯੋਗੀ ਲੱਗੇਗਾ।
ਟੂਲ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ: ਆਪਣਾ ਟੈਕਸਟ ਪੇਸਟ ਕਰੋ ਜਾਂ ਟਾਈਪ ਕਰੋ, ਅਤੇ ਤੁਸੀਂ ਤੁਰੰਤ ਇਸਨੂੰ ਉਲਟ ਹੋਇਆ ਵੇਖ ਸਕੋਗੇ। ਟੈਕਸਟ ਇਨਵਰਜ਼ਨ ਦਿਲਚਸਪ ਇਸ ਲਈ ਹੈ ਕਿ ਇਹ ਅਵਧਾਰਣਾ ਵਿੱਚ ਬਹੁਤ ਸਰਲ ਹੈ (ਬੱਸ ਉਲਟ ਪੜ੍ਹੋ), ਫਿਰ ਵੀ ਇਹ ਪ੍ਰੋਗਰਾਮਿੰਗ, ਐਨਕ੍ਰਿਪਸ਼ਨ ਅਤੇ ਟੈਕਸਟ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਕੁਝ ਵਾਕਈ ਉਪਯੋਗੀ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਸ਼ਕਤੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
ਇੱਥੇ ਮਾਮਲਾ ਇਹ ਹੈ—ਮੈਂ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਡੀਬੱਗਿੰਗ ਲਈ, ਡਿਜ਼ਾਈਨਰਾਂ ਨੂੰ ਵਿਜ਼ੁਅਲ ਪ੍ਰਭਾਵਾਂ ਲਈ, ਅਤੇ ਸਿੱਖਿਆਵੀਆਂ ਨੂੰ ਸਟਰਿੰਗ ਮੈਨੂਪੁਲੇਸ਼ਨ ਸਿਖਾਉਣ ਲਈ ਟੈਕਸਟ ਉਲਟਾਈ ਦਾ ਉਪਯੋਗ ਕਰਦੇ ਹੋਏ ਦੇਖਿਆ ਹੈ। ਇੱਕ ਆਮ ਸਥਿਤੀ ਉਹ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਪੈਲਿੰਡਰੋਮ ਪਛਾਣ ਐਲਗੋਰਿਦਮ ਉੱਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਆਪਣੀ ਲੌਜਿਕ ਨੂੰ ਟੈਸਟ ਕੇਸਾਂ ਨਾਲ ਜਲਦੀ ਤੋਂ ਜਲਦੀ ਜਾਂਚਣਾ ਚਾਹੁੰਦੇ ਹੋ।
ਇਸ ਉਲਟਾ ਟੈਕਸਟ ਟੂਲ ਨੂੰ ਵਰਤਣ ਲਈ ਤਿੰਨ ਸਰਲ ਕਦਮ ਹਨ:
ਟੂਲ ਸਭ ਕੁਝ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਪਰੋਸੈਸ ਕਰਦਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਪ੍ਰਯੋਗ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਟਾਈਪ ਕਰਦੇ ਹੋਏ ਨਤੀਜੇ ਵੇਖ ਸਕਦੇ ਹੋ। ਕਿਸੇ ਵੀ ਅੱਖਰ ਸੈੱਟ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ—ਅੰਗਰੇਜ਼ੀ, ਈਮੋਜੀ, ਵਿਸ਼ੇਸ਼ ਚਿੰਨ੍ਹ, ਯਹਾਂ ਤੱਕ ਕਿ ਜਾਪਾਨੀ ਜਾਂ ਅਰਬੀ ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਯੂਨੀਕੋਡ ਅੱਖਰ।
ਇੱਥੇ ਦੇਖੋ ਕਿ ਟੈਕਸਟ ਉਲਟਾਉਣਾ ਗਣਿਤੀ ਤੌਰ 'ਤੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਇੱਕ ਸਟਰਿੰਗ ਦੀ ਲੰਬਾਈ ਵਾਲੇ ਅੱਖਰਾਂ ਲਈ, ਉਲਟੀ ਸਟਰਿੰਗ ਇਸ ਤਰ੍ਹਾਂ ਹੈ:
ਵਾਸਤਵਿਕਤਾ ਵਿੱਚ, ਪ੍ਰੋਗਰਾਮਰ ਇਸਨੂੰ ਤਿੰਨ ਮੁੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਲਾਗੂ ਕਰਦੇ ਹਨ:
ਕਾਰਗੁਜ਼ਾਰੀ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ: ਟੈਕਸਟ ਉਲਟਾਉਣਾ ਸਮਾਂ ਜਟਿਲਤਾ (ਰੈਖਿਕ) ਵਿੱਚ ਚੱਲਦਾ ਹੈ ਕਿਉਂਕਿ ਹਰੇਕ ਅੱਖਰ ਨੂੰ ਬਿਲਕੁਲ ਇੱਕ ਵਾਰ ਸੰਸਾਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸਪੇਸ ਜਟਿਲਤਾ ਵੀ ਹੈ ਕਿਉਂਕਿ ਤੁਹਾਨੂੰ ਉਲਟੀ ਸਟਰਿੰਗ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਵਾਸਤਵਿਕ ਵਰਤੋਂ ਲਈ ਕੁਝ ਮੈਗਾਬਾਈਟਸ ਤੋਂ ਘੱਟ ਟੈਕਸਟ ਲਈ, ਕਾਰਗੁਜ਼ਾਰੀ ਤੁਰੰਤ ਹੈ।
ਇੱਕ ਚੀਜ਼ ਜੋ ਯੋਗ ਹੈ—ਜੇਕਰ ਤੁਸੀਂ ਵਿਸ਼ਾਲ ਟੈਕਸਟ ਫਾਈਲਾਂ (ਜਿਵੇਂ ਕਿ ਲੌਗ ਜਾਂ ਡਾਟਾਸੈਟ) ਨੂੰ ਉਲਟ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਵਾਰ ਵਿੱਚ ਸਭ ਕੁਝ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਨ ਤੋਂ ਬਚਣ ਲਈ ਸਟਰੀਮਿੰਗ ਦਃ ਦਿਸ਼ਾਵਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਮੈਂ ਤੁਹਾਨੂੰ ਬਿਲਕੁਲ ਦੱਸਦਾ ਹਾਂ ਕਿ ਉਲਟਾ ਕਰਨ ਵਾਲਾ ਐਲਗੋਰਿਦਮ ਤੁਹਾਡੇ ਟੈਕਸਟ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰੋਸੈਸ ਕਰਦਾ ਹੈ:
ਵਿਵਹਾਰਕ ਉਦਾਹਰਣ "Hello, World!" ਨਾਲ:
1ਇਨਪੁਟ: "Hello, World!"
2ਕਦਮ 1: ਖਾਲੀ ਨਤੀਜਾ ਸ਼ੁਰੂ ਕਰੋ: ""
3ਕਦਮ 2: ਆਖਰੀ ਅੱਖਰ "!" ਲਓ → ਨਤੀਜਾ = "!"
4ਕਦਮ 3: "d" ਲਓ → ਨਤੀਜਾ = "!d"
5ਕਦਮ 4: "l" ਲਓ → ਨਤੀਜਾ = "!dl"
6ਕਦਮ 5: ਹਰ ਅੱਖਰ ਲਈ ਜਾਰੀ ਰੱਖੋ...
7ਅੰਤਮ ਆਉਟਪੁਟ: "!dlroW ,olleH"
8ਐਲਗੋਰਿਦਮ ਹਰ ਅੱਖਰ ਨੂੰ ਇੱਕੋ ਤਰ੍ਹਾਂ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ—ਭਾਵੇਂ ਇਹ ਅੱਖਰ, ਨੰਬਰ, ਵਿਰਾਮ ਚਿੰਨ੍ਹ, ਸਪੇਸ, ਜਾਂ ਈਮੋਜੀ ਹੋਵੇ। ਸਭ ਕੁਝ ਉਲਟੇ ਆਉਟਪੁਟ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਹ ਸੰਗਤ ਹੈਂਡਲਿੰਗ ਇਸ ਲਈ ਹੈ ਕਿ ਇਹ ਵੱਖ-ਵੱਖ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਅੱਖਰ ਸੈੱਟ ਵਿੱਚ ਵਿਸ਼ਵਾਸਯੋਗ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।
ਟੈਕਸਟ ਉਲਟਾ ਕਰਨ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਕੁਝ ਦਿਲਚਸਪ ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਨੂੰ ਮਿਲੋਗੇ:
ਖਾਲੀ ਸਟਰਿੰਗ: ਖਾਲੀ ਸਟਰਿੰਗ ਨੂੰ ਉਲਟਾ ਕਰਨ ਤੇ ਤੁਹਾਨੂੰ... ਇੱਕ ਖਾਲੀ ਸਟਰਿੰਗ ਮਿਲਦੀ ਹੈ। ਸਮਝ ਆਇਆ, ਠੀਕ ਹੈ? ਉਲਟਾ ਕਰਨ ਲਈ ਕੁਝ ਨਹੀਂ।
ਇੱਕ ਅੱਖਰ: "A" ਨੂੰ ਉਲਟਾ ਕਰੋ ਅਤੇ ਤੁਹਾਨੂੰ "A" ਮਿਲਦਾ ਹੈ। ਇਹ ਆਪਣਾ ਉਲਟਾ ਹੈ, ਜਿਵੇਂ ਸਾਰੇ ਇੱਕ ਅੱਖਰ।
ਯੂਨੀਕੋਡ ਅਤੇ ਈਮੋਜੀ: ਇੱਥੇ ਚੀਜ਼ਾਂ ਦਿਲਚਸਪ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਐਲਗੋਰਿਦਮ ਯੂਨੀਕੋਡ ਨੂੰ ਠੀਕ ਤਰ੍ਹਾਂ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਈਮੋਜੀ, ਜਾਪਾਨੀ ਅੱਖਰ, ਅਰਬੀ ਲਿਪੀ ਅਤੇ ਹੋਰ ਗੈਰ-ਲੈਟਿਨ ਟੈਕਸਟ ਸ਼ਾਮਲ ਹਨ। "こんにちは 🌍" ਨਾਲ ਇਸ ਨੂੰ ਟੈਸਟ ਕਰੋ ਅਤੇ ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਇਹ ਠੀਕ ਤਰ੍ਹਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।
ਵਹਾਈਟਸਪੇਸ ਅਤੇ ਵਿਸ਼ੇਸ਼ ਅੱਖਰ: ਸਪੇਸ, ਟੈਬ, ਨਵੀਂ ਲਾਈਨ, ਵਿਰਾਮ ਚਿੰਨ੍ਹ—ਸਭ ਕੁਝ ਬਿਲਕੁਲ ਉਲਟਾ ਹੋ ਜਾਂਦਾ ਹੈ। "Hello World" (3 ਸਪੇਸ ਦੇ ਨਾਲ) "dlroW olleH" (ਅਜੇ ਵੀ 3 ਸਪੇਸ) ਬਣ ਜਾਂਦਾ ਹੈ।
ਬਹੁਤ ਲੰਬਾ ਟੈਕਸਟ: ਬਹੁਤ ਵੱਡੇ ਇਨਪੁਟ ਲਈ (ਮੈਗਾਬਾਈਟਸ ਦੇ ਟੈਕਸਟ ਦੀ ਸੋਚ), ਤੁਸੀਂ ਉਪਲਬਧ ਮੈਮੋਰੀ ਤੱਕ ਸੀਮਤ ਹੋ। ਜਿਆਦਾਤਰ ਆਧੁਨਿਕ ਸਿਸਟਮ ਇਸ ਨੂੰ ਕਈ ਮੈਗਾਬਾਈਟ ਤੱਕ ਠੀਕ ਤਰ੍ਹਾਂ ਨਾਲ ਸੰਭਾਲਦੇ ਹਨ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਗਿਗਾਬਾਈਟ ਆਕਾਰ ਦੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਪਰੋਸੇਸ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਸਭ ਕੁਝ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਨ ਦੀ ਬਜਾਏ ਇੱਕ ਸਟਰੀਮਿੰਗ ਹੱਲ ਚਾਹੀਦਾ ਹੈ।
ਇੱਕ ਚੀਜ਼ ਜੋ ਮੈਂ ਨੋਟ ਕੀਤੀ ਹੈ: ਕੰਬਾਈਨਿੰਗ ਅੱਖਰ ਅਤੇ ਗ੍ਰਾਫ਼ੀਮ ਕਲਸਟਰ ਕਈ ਵਾਰ ਅਣਉਮੀਦ ਤਰੀਕੇ ਨਾਲ ਵਿਵਹਾਰ ਕਰ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਤਵਚਾ ਦੇ ਰੰਗ ਦੇ ਸੋਧਕ ਵਾਲੇ ਈਮੋਜੀ ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਕਈ ਯੂਨੀਕੋਡ ਕੋਡ ਪੁਆਇੰਟ ਹਨ। ਜਿਆਦਾਤਰ ਲਾਗੂਕਰਣ ਇਸ ਨੂੰ ਠੀਕ ਤਰ੍ਹਾਂ ਨਾਲ ਸੰਭਾਲਦੇ ਹਨ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਜਟਿਲ ਯੂਨੀਕੋਡ ਦੇ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਆਪਣੇ ਵਿਸ਼ੇਸ਼ ਉਪਯੋਗ ਕੇਸ ਨਾਲ ਇਸ ਨੂੰ ਟੈਸਟ ਕਰਨਾ ਯੋਗ ਹੈ।
ਤੁਸੀਂ ਹੈਰਾਨ ਹੋ ਸਕਦੇ ਹੋ ਕਿ ਟੈਕਸਟ ਉਲਟਾਉਣ ਕਿੰਨੀ ਵਾਰ ਪ੍ਰੈਕਟਿਸ ਵਿੱਚ ਆਉਂਦਾ ਹੈ। ਇੱਥੇ ਉਹ ਸਥਿਤੀਆਂ ਹਨ ਜਿੱਥੇ ਮੈਂ ਇਸਦੀ ਵਰਤੋਂ ਵੇਖੀ ਹੈ:
ਪੈਲਿੰਡਰੋਮ ਜਾਂਚ: ਜਦੋਂ ਤੁਹਾਨੂੰ ਇਹ ਜਾਂਚਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਕੋਈ ਸ਼ਬਦ ਅੱਗੇ ਅਤੇ ਪਿੱਛੇ ਇੱਕੋ ਤਰ੍ਹਾਂ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਤੁਸੀਂ ਇਸਨੂੰ ਉਲਟ ਕੇ ਤੁਲਨਾ ਕਰਦੇ ਹੋ। ਸੋਚੋ "racecar" → "racecar" (ਮਿਲਦਾ ਹੈ = ਪੈਲਿੰਡਰੋਮ)।
ਸਟਰਿੰਗ ਐਲਗੋਰਿਦਮ ਅਭਿਆਸ: ਟੈਕਸਟ ਉਲਟਾਉਣਾ ਇੱਕ ਕਲਾਸਿਕ ਕੋਡਿੰਗ ਇੰਟਰਵਿਊ ਸਮੱਸਿਆ ਹੈ ਜੋ ਤੁਹਾਡੀ ਸਟਰਿੰਗ ਮੈਨਿਪੁਲੇਸ਼ਨ ਅਤੇ ਬੁਨਿਆਦੀ ਡਾਟਾ ਸਟਰਕਚਰ ਦੀ ਸਮਝ ਦੀ ਜਾਂਚ ਕਰਦੀ ਹੈ।
ਸਟੈਕ ਲਾਗੂਕਰਨ ਡੈਮੋ: ਟੈਕਸਟ ਉਲਟਾਉਣਾ LIFO (ਲਾਸਟ-ਇਨ-ਫਰਸਟ-ਆਉਟ) ਵਿਵਹਾਰ ਸਿਖਾਉਣ ਲਈ ਬਿਲਕੁਲ ਸਹੀ ਉਦਾਹਰਣ ਹੈ ਕਿਉਂਕਿ ਇੱਕ ਸਟੈਕ ਸਵਾਭਾਵਿਕ ਤੌਰ 'ਤੇ ਆਰਡਰ ਉਲਟ ਦਿੰਦਾ ਹੈ।
ਬੁਨਿਆਦੀ ਐਨਕੋਡਿੰਗ: ਆਪਣੇ ਆਪ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਨਹੀਂ, ਟੈਕਸਟ ਉਲਟਾਉਣਾ ਕਈ ਵਾਰ ਬਹੁ-ਪੜਾਅ ਵਾਲੀ ਐਨਕੋਡਿੰਗ ਯੋਜਨਾਵਾਂ ਵਿੱਚ ਇੱਕ ਪਰਤ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਅਸਲ ਐਨਕ੍ਰਿਪਸ਼ਨ ਨਾਲੋਂ ਵਧੇਰੇ ਅਸਪਸ਼ਟੀਕਰਨ ਬਾਰੇ ਹੈ।
ਚੁਣੌਤੀ-ਪ੍ਰਤੀਕ੍ਰਿਆ ਸਿਸਟਮ: ਕੁਝ ਪ੍ਰਮਾਣੀਕਰਨ ਸਿਸਟਮ ਆਪਣੀ ਤਸਦੀਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਉਲਟੇ ਸਟਰਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।
(ਅਨੁਵਾਦ ਜਾਰੀ...)
ਟੈਕਸਟ ਉਲਟਾਉਣ ਤੁਹਾਡੇ ਸੋਚੇ ਤੋਂ ਬਹੁਤ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਹੈ—ਪੁਰਾਣੀਆਂ ਲਿਖਣ ਪ੍ਰਣਾਲੀਆਂ ਤੋਂ ਲੈ ਕੇ ਆਧੁਨਿਕ ਕੰਪਿਊਟਿੰਗ ਤੱਕ।
ਪੁਰਾਣੀਆਂ ਸਭਿਅਤਾਵਾਂ ਨੇ ਕੰਪਿਊਟਰ ਦੇ ਮੌਜੂਦ ਹੋਣ ਤੋਂ ਬਹੁਤ ਪਹਿਲਾਂ ਦਿਸ਼ਾਤਮਕ ਲਿਖਾਈ ਨਾਲ ਪ੍ਰਯੋਗ ਕੀਤੇ। ਯੂਨਾਨੀ ਅਤੇ ਮਿਸਰੀ ਕਈ ਵਾਰ "ਬੌਸਟ੍ਰੋਫੇਡੋਨ" ਸਟਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਨ, ਜਿੱਥੇ ਲਾਈਨਾਂ ਵਿੱਚ ਬਦਲਦੀ ਦਿਸ਼ਾ ਹੁੰਦੀ ਸੀ—ਖੱਬੇ ਤੋਂ ਸੱਜੇ, ਫਿਰ ਸੱਜੇ ਤੋਂ ਖੱਬੇ, ਇੱਕ਼ ਬਲਦ ਵਾਂਗ ਜੋ ਖੇਤ ਵਿੱਚ ਹਲ ਚਲਾਉਂਦਾ ਹੈ (ਜੋ ਕਿ "ਬੌਸਟ੍ਰੋਫੇਡੋਨ" ਦਾ ਅਰਥ ਹੈ)।
ਲਿਓਨਾਰਡੋ ਡਾ ਵਿੰਚੀ ਨੇ ਆਪਣੀਆਂ ਨੋਟਬੁੱਕਾਂ ਨੂੰ ਮਿਰਰ ਲਿਖਾਈ ਨਾਲ ਭਰ ਦਿੱਤਾ, ਜਿੱਥੇ ਟੈਕਸਟ ਉਲਟਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਇਤਿਹਾਸਕਾਰ ਇਸ ਬਾਰੇ ਬਹਿਸ ਕਰਦੇ ਹਨ ਕਿ ਕੀ ਇਹ ਗੁਪਤਤਾ ਲਈ ਸੀ, ਕਿਉਂਕਿ ਉਹ ਖੱਬੇ ਹੱਥ ਦਾ ਸੀ ਅਤੇ ਇਹ ਉਸ ਲਈ ਵਧੇਰੇ ਆਰਾਮਦਾਇਕ ਸੀ, ਜਾਂ ਬਸ ਸਿਆਹੀ ਧੱਬੇ ਨੂੰ ਰੋਕਣ ਲਈ। ਜੋ ਵੀ ਕਾਰਨ ਹੋਵੇ, ਉਸਦੀਆਂ ਨੋਟਬੁੱਕਾਂ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਕਿ ਟੈਕਸਟ ਉਲਟਾਉਣ ਨੂੰ ਸਦੀਆਂ ਤੋਂ ਇੱਕ ਐਨਕੋਡਿੰਗ ਤਕਨੀਕ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਰਿਹਾ ਹੈ।
ਜਦੋਂ 1950-60 ਦੇ ਦਹਾਕੇ ਵਿੱਚ ਕੰਪਿਊਟਰ ਆਏ, ਤਾਂ ਸਟ੍ਰਿੰਗ ਮੈਨੂਪੁਲੇਸ਼ਨ ਇੱਕ ਮੂਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਅਭਿਆਸ ਬਣ ਗਿਆ। ਟੈਕਸਟ ਉਲਟਾਉਣਾ ਉਨ੍ਹਾਂ ਕਲਾਸਿਕ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਸੀ ਜਿਸ ਨੂੰ ਹਰ ਪ੍ਰੋਗਰਾਮਰ ਨੇ ਸਿੱਖਿਆ, ਵਰਤਣ ਅਤੇ ਖੋਜ ਦੇ ਨਾਲ-ਨਾਲ।
ਜੋ ਇਸ ਨੂੰ ਖਾਸ ਤੌਰ 'ਤੇ ਦਿਲਚਸਪ ਬਣਾਉਂਦਾ ਸੀ: ਸਟੈਕ ਡਾਟਾ ਸਟਰਕਚਰ ਦਾ ਵਿਕਾਸ ਸਵਾਭਾਵਿਕ ਤੌਰ 'ਤੇ ਟੈਕਸਟ ਉਲਟਾਉਣ ਨਾਲ ਜੁੜ ਗਿਆ। ਇੱਕ ਸਟੈਕ ਦਾ LIFO (ਲਾਸਟ-ਇਨ-ਫਰਸਟ-ਆਉਟ) ਵਿਵਹਾਰ ਆਪਣੇ ਆਪ ਆਰਡਰ ਨੂੰ ਉਲਟ ਦਿੰਦਾ ਹੈ—"HELLO" ਅੱਖਰ ਦਰ ਅੱਖਰ ਇੱਕ ਸਟੈਕ 'ਤੇ ਧੱਕੋ, ਫਿਰ ਉਨ੍ਹਾਂ ਨੂੰ ਹੇਠਾਂ ਕੱਢੋ, ਅਤੇ ਤੁਹਾਨੂੰ "OLLEH" ਮਿਲੇਗਾ। ਇਹ ਸੁੰਦਰ ਸੰਬੰਧ ਨੇ ਟੈਕਸਟ ਉਲਟਾਉਣ ਨੂੰ ਡਾਟਾ ਸਟਰਕਚਰ ਸਿਖਾਉਣ ਲਈ ਇੱਕ ਉਦਾਹਰਨ ਬਣਾ ਦਿੱਤਾ।
ਅੱਜ, ਤੁਸੀਂ ਟੈਕਸਟ ਉਲਟਾਉਣ ਐਲਗੋਰਿਦਮ ਨੂੰ ਕਈ ਥਾਵਾਂ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹੋਏ ਪਾਓਗੇ:
ਐਲਗੋਰਿਦਮ ਦੀ ਸਰਲਤਾ (ਇਹ ਉਹ ਪਹਿਲਾ ਹੈ ਜੋ ਤੁਸੀਂ ਸਿੱਖਦੇ ਹੋ) ਅਤੇ ਇਸਦੀ ਵਿਵਹਾਰਕ ਉਪਯੋਗਿਤਾ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ ਕਿ ਇਹ ਆਪਣੀ ਪਹਿਲੀ ਲਾਗੂਕਰਨ ਤੋਂ ਦਹਾਕਿਆਂ ਬਾਅਦ ਵੀ ਪ੍ਰਾਸੰਗਿਕ ਰਹੇ।
ਇੱਥੇ ਲੋਕਪਰਿਯ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਟੈਕਸਟ ਉਲਟਾਵੇ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਤਰੀਕਾ ਹੈ। ਹਰ ਉਦਾਹਰਣ ਮੁੱਖ ਐਲਗੋਰਿਦਮ ਅਤੇ ਵਿਵਹਾਰਕ ਵਰਤੋਂ ਦਿਖਾਉਂਦੀ ਹੈ:
1' ਟੈਕਸਟ ਉਲਟਾਵੇ ਲਈ Excel VBA ਫੰਕਸ਼ਨ
2Function InvertText(inputText As String) As String
3 Dim i As Integer
4 Dim result As String
5
6 result = ""
7 For i = Len(inputText) To 1 Step -1
8 result = result & Mid(inputText, i, 1)
9 Next i
10
11 InvertText = result
12End Function
13' ਸੈੱਲ ਵਿੱਚ ਵਰਤੋਂ:
14' =InvertText("ਹੈਲੋ, ਵਰਲਡ!")
151def invert_text(input_text):
2 """ਇੱਕ ਸਟਰਿੰਗ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਕ੍ਰਮ ਉਲਟਾਓ।"""
3 return input_text[::-1]
41original_text = "ਹੈਲੋ, ਵਰਲਡ!"
2inverted_text = invert_text(original_text)
3print(f"ਮੂਲ: {original_text}")
4print(f"ਉਲਟਾ: {inverted_text}")
5
6# ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
7unicode_text = "こんにちは世界! 🌍"
8inverted_unicode = invert_text(unicode_text)
9print(f"ਮੂਲ ਯੂਨੀਕੋਡ: {unicode_text}")
10print(f"ਉਲਟਾ ਯੂਨੀਕੋਡ: {inverted_unicode}")
111function invertText(inputText) {
2 return inputText.split('').reverse().join('');
3}
4
5// ਉਦਾਹਰਣ ਵਰਤੋਂ:
6const originalText = "ਹੈਲੋ, ਵਰਲਡ!";
7const invertedText = invertText(originalText);
8console.log(`ਮੂਲ: ${originalText}`);
9console.log(`ਉਲਟਾ: ${invertedText}`);
10
11// ਖਾਲੀ ਸਟਰਿੰਗ ਨੂੰ ਸੰਭਾਲਣਾ
12console.log(`ਖਾਲੀ ਸਟਰਿੰਗ ਉਲਟਾ: "${invertText("")}"`);
13
14// ਯੂਨੀਕੋਡ ਨੂੰ ਸੰਭਾਲਣਾ
15const unicodeText = "こんにちは世界! 🌍";
16console.log(`ਮੂਲ ਯੂਨੀਕੋਡ: ${unicodeText}`);
17console.log(`ਉਲਟਾ ਯੂਨੀਕੋਡ: ${invertText(unicodeText)}`);
181public class TextInverter {
2 public static String invertText(String inputText) {
3 return new StringBuilder(inputText).reverse().toString();
4 }
5
6 public static void main(String[] args) {
7 String originalText = "ਹੈਲੋ, ਵਰਲਡ!";
8 String invertedText = invertText(originalText);
9
10 System.out.println("ਮੂਲ: " + originalText);
11 System.out.println("ਉਲਟਾ: " + invertedText);
12
13 // ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
14 String unicodeText = "こんにちは世界! 🌍";
15 String invertedUnicode = invertText(unicodeText);
16 System.out.println("ਮੂਲ ਯੂਨੀਕੋਡ: " + unicodeText);
17 System.out.println("ਉਲਟਾ ਯੂਨੀਕੋਡ: " + invertedUnicode);
18 }
19}
201invert_text <- function(input_text) {
2 # ਅੱਖਰ ਵੈਕਟਰ ਵਿੱਚ ਬਦਲੋ, ਉਲਟਾਓ ਅਤੇ ਜੋੜੋ
3 paste(rev(strsplit(input_text, "")[[1]]), collapse = "")
4}
5
6# ਉਦਾਹਰਣ ਵਰਤੋਂ
7original_text <- "ਹੈਲੋ, ਵਰਲਡ!"
8inverted_text <- invert_text(original_text)
9cat("ਮੂਲ:", original_text, "\n")
10cat("ਉਲਟਾ:", inverted_text, "\n")
111function invertedText = invertText(inputText)
2 % ਸਟਰਿੰਗ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਕ੍ਰਮ ਉਲਟਾਉਣ ਲਈ ਫੰਕਸ਼ਨ
3 invertedText = inputText(end:-1:1);
4end
5
6% ਉਦਾਹਰਣ ਵਰਤੋਂ
7originalText = 'ਹੈਲੋ, ਵਰਲਡ!';
8invertedText = invertText(originalText);
9fprintf('ਮੂਲ: %s\n', originalText);
10fprintf('ਉਲਟਾ: %s\n', invertedText);
111#include <iostream>
2#include <string>
3#include <algorithm>
4
5std::string invertText(const std::string& inputText) {
6 std::string result = inputText;
7 std::reverse(result.begin(), result.end());
8 return result;
9}
10
11int main() {
12 std::string originalText = "ਹੈਲੋ, ਵਰਲਡ!";
13 std::string invertedText = invertText(originalText);
14
15 std::cout << "ਮੂਲ: " << originalText << std::endl;
16 std::cout << "ਉਲਟਾ: " << invertedText << std::endl;
17
18 // ਖਾਲੀ ਸਟਰਿੰਗ ਨੂੰ ਸੰਭਾਲਣਾ
19 std::cout << "ਖਾਲੀ ਸਟਰਿੰਗ ਉਲਟਾ: \"" << invertText("") << "\"" << std::endl;
20
21 return 0;
22}
231def invert_text(input_text)
2 input_text.reverse
3end
4
5# ਉਦਾਹਰਣ ਵਰਤੋਂ
6original_text = "ਹੈਲੋ, ਵਰਲਡ!"
7inverted_text = invert_text(original_text)
8puts "ਮੂਲ: #{original_text}"
9puts "ਉਲਟਾ: #{inverted_text}"
10
11# ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
12unicode_text = "こんにちは世界! 🌍"
13inverted_unicode = invert_text(unicode_text)
14puts "ਮੂਲ ਯੂਨੀਕੋਡ: #{unicode_text}"
15puts "ਉਲਟਾ ਯੂਨੀਕੋਡ: #{inverted_unicode}"
161<?php
2function invertText($inputText) {
3 return strrev($inputText);
4}
5
6// ਉਦਾਹਰਣ ਵਰਤੋਂ
7$originalText = "ਹੈਲੋ, ਵਰਲਡ!";
8$invertedText = invertText($originalText);
9echo "ਮੂਲ: $originalText\n";
10echo "ਉਲਟਾ: $invertedText\n";
11
12// ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
13$unicodeText = "こんにちは世界! 🌍";
14$invertedUnicode = invertText($unicodeText);
15echo "ਮੂਲ ਯੂਨੀਕੋਡ: $unicodeText\n";
16echo "ਉਲਟਾ ਯੂਨੀਕੋਡ: $invertedUnicode\n";
17?>
181fn invert_text(input_text: &str) -> String {
2 input_text.chars().rev().collect()
3}
4
5fn main() {
6 let original_text = "ਹੈਲੋ, ਵਰਲਡ!";
7 let inverted_text = invert_text(original_text);
8
9 println!("ਮੂਲ: {}", original_text);
10 println!("ਉਲਟਾ: {}", inverted_text);
11
12 // ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
13 let unicode_text = "こんにちは世界! 🌍";
14 let inverted_unicode = invert_text(unicode_text);
15 println!("ਮੂਲ ਯੂਨੀਕੋਡ: {}", unicode_text);
16 println!("ਉਲਟਾ ਯੂਨੀਕੋਡ: {}", inverted_unicode);
17}
181using System;
2
3class TextInverter
4{
5 public static string InvertText(string inputText)
6 {
7 char[] charArray = inputText.ToCharArray();
8 Array.Reverse(charArray);
9 return new string(charArray);
10 }
11
12 static void Main()
13 {
14 string originalText = "ਹੈਲੋ, ਵਰਲਡ!";
15 string invertedText = InvertText(originalText);
16
17 Console.WriteLine($"ਮੂਲ: {originalText}");
18 Console.WriteLine($"ਉਲਟਾ: {invertedText}");
19
20 // ਖਾਲੀ ਸਟਰਿੰਗ ਨੂੰ ਸੰਭਾਲਣਾ
21 Console.WriteLine($"ਖਾਲੀ ਸਟਰਿੰਗ ਉਲਟਾ: \"{InvertText("")}\"");
22
23 // ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
24 string unicodeText = "こんにちは世界! 🌍";
25 string invertedUnicode = InvertText(unicodeText);
26 Console.WriteLine($"ਮੂਲ ਯੂਨੀਕੋਡ: {unicodeText}");
27 Console.WriteLine($"ਉਲਟਾ ਯੂਨੀਕੋਡ: {invertedUnicode}");
28 }
29}
301package main
2
3import (
4 "fmt"
5)
6
7func invertText(inputText string) string {
8 runes := []rune(inputText)
9 for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
10 runes[i], runes[j] = runes[j], runes[i]
11 }
12 return string(runes)
13}
14
15func main() {
16 originalText := "ਹੈਲੋ, ਵਰਲਡ!"
17 invertedText := invertText(originalText)
18
19 fmt.Printf("ਮੂਲ: %s\n", originalText)
20 fmt.Printf("ਉਲਟਾ: %s\n", invertedText)
21
22 // ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
23 unicodeText := "こんにちは世界! 🌍"
24 invertedUnicode := invertText(unicodeText)
25 fmt.Printf("ਮੂਲ ਯੂਨੀਕੋਡ: %s\n", unicodeText)
26 fmt.Printf("ਉਲਟਾ ਯੂਨੀਕੋਡ: %s\n", invertedUnicode)
27}
281func invertText(_ inputText: String) -> String {
2 return String(inputText.reversed())
3}
4
5// ਉਦਾਹਰਣ ਵਰਤੋਂ
6let originalText = "ਹੈਲੋ, ਵਰਲਡ!"
7let invertedText = invertText(originalText)
8
9print("ਮੂਲ: \(originalText)")
10print("ਉਲਟਾ: \(invertedText)")
11
12// ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
13let unicodeText = "こんにちは世界! 🌍"
14let invertedUnicode = invertText(unicodeText)
15print("ਮੂਲ ਯੂਨੀਕੋਡ: \(unicodeText)")
16print("ਉਲਟਾ ਯੂਨੀਕੋਡ: \(invertedUnicode)")
17ਜੇਕਰ ਤੁਸੀਂ ਉਤਪਾਦਨ ਕੋਡ ਵਿੱਚ ਪਾਠ ਉਲਟਾਉਣ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਇੱਥੇ ਕੁਝ ਪ੍ਰਦਰਸ਼ਨ ਕਾਰਕ ਹਨ ਜਿਨ੍ਹਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰਨ ਯੋਗ ਹੈ:
ਮੈਮੋਰੀ ਵਰਤੋਂ: ਉਲਟਾ ਕਾਪੀ ਬਣਾਉਣ ਲਈ ਤੁਹਾਡੇ ਇਨਪੁਟ ਦੇ ਆਕਾਰ ਦੇ ਬਰਾਬਰ ਮੈਮੋਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਛੋਟੇ ਤੋਂ ਮੱਧਮ ਸਟਰਿੰਗਾਂ (1 ਐਮਬੀ ਤੋਂ ਘੱਟ) ਲਈ, ਇਹ ਨਗਣ ਹੈ। ਵੱਡੇ ਪਾਠ ਲਈ, ਤੁਸੀਂ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਨੂੰ ਅੱਧਾ ਕਰ ਰਹੇ ਹੋ।
ਮੌਜੂਦਾ ਥਾਂ 'ਤੇ ਉਲਟਾਉਣਾ: C, C++, ਅਤੇ Rust ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਤੁਹਾਨੂੰ ਕੈਰੇਕਟਰ ਐਰੇਜ਼ ਨੂੰ ਸਿੱਧੇ ਮੈਮੋਰੀ ਵਿੱਚ ਬਿਨਾਂ ਕਾਪੀ ਬਣਾਏ ਉਲਟਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀਆਂ ਹਨ। ਇਹ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਨੂੰ ਅੱਧਾ ਕਰ ਦਿੰਦਾ ਹੈ ਪਰ ਸਿਰਫ਼ ਬਦਲਣਯੋਗ ਸਟਰਿੰਗਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ। ਬਹੁਤ ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ (Python, JavaScript, Java) ਅਪਰਿਵਰਤਨੀਯ ਸਟਰਿੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ, ਇਸਲਈ ਤੁਹਾਨੂੰ ਇੱਕ ਨਵੀਂ ਬਣਾਉਣੀ ਪਵੇਗੀ।
ਯੂਨੀਕੋਡ ਹੈਂਡਲਿੰਗ: ਇੱਥੇ ਚੀਜ਼ਾਂ ਜਟਿਲ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਬਹੁ-ਬਾਈਟ ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਹੈਂਡਲ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਾਂ ਤੁਸੀਂ ਇਨਕੋਡਿੰਗ ਨੂੰ ਭੰਗ ਕਰ ਦਓਗੇ। ਬਹੁਤ ਸਾਰੀਆਂ ਆਧੁਨਿਕ ਭਾਸ਼ਾ ਦੀਆਂ ਮਾ�नਕ ਲਾਇਬ੍ਰੇਰੀਆਂ ਇਸ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਹੈਂਡਲ ਕਰਦੀਆਂ ਹਨ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਨਿਮਨ ਸਤਰ ਦਾ ਕੋਡ ਲਿਖ ਰਹੇ ਹੋ ਜਾਂ ਸਿੱਧੇ ਬਾਈਟ ਐਰੇਜ਼ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਸਾਵਧਾਨ ਰਹੋ। ਜਾਂਚ ਕਰੋ ਕਿ ਇਮੋਜੀ ਅਤੇ ਗੈਰ-ਲੈਟਿਨ ਲਿਪੀਆਂ ਨਾਲ ਸਭ ਠੀਕ ਹੈ।
ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਲਈ ਸਟਰੀਮਿੰਗ: ਜੇਕਰ ਤੁਸੀਂ ਗਿਗਾਬਾਈਟ ਦੇ ਆਕਾਰ ਦੇ ਲੌਗ ਫਾਈਲਾਂ ਜਾਂ ਡੇਟਾਸੈਟਾਂ ਨੂੰ ਉਲਟਾ ਰਹੇ ਹੋ, ਤਾਂ ਸਭ ਕੁਝ ਮੈਮੋਰੀ ਵਿੱਚ ਨਾ ਲੋਡ ਕਰੋ। ਇੱਕ ਸਟਰੀਮਿੰਗ ਦਾ ਤਰੀਕਾ ਵਰਤੋ—ਅੰਤ ਤੋਂ ਚੰਕ ਪੜ੍ਹੋ, ਜਿਵੇਂ ਤੁਸੀਂ ਜਾਂਦੇ ਹੋ ਉਨ੍ਹਾਂ ਨੂੰ ਲਿਖੋ। ਯੂਨੀਕੋਡ ਤਕਨੀਕੀ ਮਾਨਕ #18 ਦੇ ਅਨੁਸਾਰ, ਗ੍ਰਾਫ਼ੀਮ ਕਲੱਸਟਰ ਹੈਂਡਲਿੰਗ ਲਈ ਸਹੀ ਪਾਠ ਸੀਮਾ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਵਿਸ਼ੇਸ਼ ਧਿਆਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਸਮਾਨਾਂਤਰਤਾ: ਬਹੁਤ ਲੰਬੀਆਂ ਸਟਰਿੰਗਾਂ ਲਈ, ਤੁਸੀਂ ਸਿਧਾਂਤਿਕ ਤੌਰ 'ਤੇ ਉਲਟਾਉਣ ਨੂੰ ਸਮਾਨਾਂਤਰ ਬਣਾ ਸਕਦੇ ਹੋ (ਚੰਕਾਂ ਵਿੱਚ ਵੰਡੋ, ਹਰੇਕ ਨੂੰ ਉਲਟੋ, ਜੋੜੋ)। ਵਾਸਤਵਿਕਤਾ ਵਿੱਚ, ਓਵਰਹੈਡ ਅਕਸਰ ਇਸਦੇ ਯੋਗ ਨਹੀਂ ਹੁੰਦਾ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਵਿਸ਼ਾਲ ਡੇਟਾਸੈਟਾਂ ਨਾਲ ਨਹੀਂ ਨਜਿੱਠ ਰਹੇ ਅਤੇ ਕੰਪਿਊਟ ਸਰੋਤ ਨਹੀਂ ਰੱਖ ਰਹੇ।
ਬਸ ਆਪਣਾ ਟੈਕਸਟ ਉੱਪਰ ਦੇ ਇਨਪੁੱਟ ਖੇਤਰ ਵਿੱਚ ਪੇਸਟ ਜਾਂ ਟਾਈਪ ਕਰੋ। ਟੂਲ ਇਸਨੂੰ ਆਪਣੇ-ਆਪ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਉਲਟ ਦਿੰਦਾ ਹੈ—ਕਿਸੇ ਬਟਨ ਨੂੰ ਕਲਿੱਕ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ। ਇੱਕ ਕਲਿੱਕ ਨਾਲ ਨਤੀਜਾ ਕਾਪੀ ਕਰੋ।
ਟੈਕਸਟ ਉਲਟਨ (ਅੱਖਰ ਉਲਟਨ) ਵਿੱਚ ਵੱਖ-ਵੱਖ ਅੱਖਰ ਉਲਟ ਜਾਂਦੇ ਹਨ: "Hello World" → "dlroW olleH"। ਸ਼ਬਦ ਉਲਟਨ ਹਰੇਕ ਸ਼ਬਦ ਨੂੰ ਅਖੰਡ ਰੱਖਦਾ ਹੈ ਪਰ ਉਨ੍ਹਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਉਲਟ ਦਿੰਦਾ ਹੈ: "Hello World" → "World Hello"। ਇਹ ਟੂਲ ਅੱਖਰ ਉਲਟਨ ਕਰਦਾ ਹੈ।
ਹਾਂ। ਟੂਲ ਸਾਰੇ ਯੂਨੀਕੋਡ ਅੱਖਰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਈਮੋਜੀ, ਚੀਨੀ/ਜਾਪਾਨੀ/ਕੋਰੀਅਨ ਟੈਕਸਟ, ਅਰਬੀ ਲਿਪੀ, ਵਿਸ਼ੇਸ਼ ਚਿੰਨ੍ਹ, ਅਤੇ ਮਿਲਾਉਣ ਵਾਲੇ ਅੱਖਰ ਸ਼ਾਮਲ ਹਨ। "こんにちは 🌍" ਨਾਲ ਆਪ ਖੁਦ ਵੇਖ ਸਕਦੇ ਹੋ।
ਇਹ ਸਬੰਧਤ ਹਨ ਪਰ ਇੱਕ ਸਮਾਨ ਨਹੀਂ। ਅੱਖਰ ਉਲਟਨ (ਜੋ ਇਹ ਟੂਲ ਕਰਦਾ ਹੈ) ਬਸ ਅੱਖਰ ਕ੍ਰਮ ਨੂੰ ਉਲਟ ਦਿੰਦਾ ਹੈ। ਦਰਪਣ ਲਿਖਾਈ ਅੱਖਰਾਂ ਨੂੱ ਹਮੋਨੀਅਲੀ ਉਲਟ ਦਿੰਦੀ ਹੈ ਤਾਂ ਜੋ ਉਹ ਦਰਪਣ ਪ੍ਰਤੀਬਿੰਬ ਵਜੋਂ ਦਿਖਾਈ ਦੇਣ। ਦਰਪਣ ਲਿਖਾਈ ਨੂੰ ਪੜ੍ਹਨ ਲਈ, ਤੁਹਾਨੂੰ ਅਸਲ ਦਰਪਣ ਜਾਂ ਹਮੋਨੀਅਲ ਉਲਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਆਮ ਵਰਤੋਂਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ: ਪੈਲਿੰਡਰੋਮ ਦੀ ਜਾਂਚ, ਪਹੇਲੀਆਂ ਲਈ ਸਧਾਰਨ ਐਨਕੋਡਿੰਗ, ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਈ ਟੈਸਟ ਡਾਟਾ ਤਿਆਰ ਕਰਨਾ, ਕਲਾਤਮਕ ਟੈਕਸਟ ਪ੍ਰਭਾਵ, ਸਟ੍ਰਿੰਗ ਐਲਗੋਰਿਦਮ ਸਿਖਾਉਣਾ, ਅਤੇ ਟੈਕਸਟ ਪ੍ਰੋਸੈਸਿੰਗ ਕੋਡ ਦੀ ਡੀਬੱਗਿੰਗ।
ਹਾਂ। ਟੈਕਸਟ ਉਲਟਨ ਆਪਣਾ ਖੁਦ ਦਾ ਉਲਟਾ ਆਪਰੇਸ਼ਨ ਹੈ। ਜੇ ਤੁਸੀਂ "Hello" ਨੂੰ "olleH" ਵਿੱਚ ਉਲਟਦੇ ਹੋ, ਫਿਰ "olleH" ਨੂੰ ਉਲਟਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਫਿਰ ਤੋਂ "Hello" ਮਿਲ ਜਾਵੇਗਾ। ਗਣਿਤੀ ਤੌਰ 'ਤੇ, ਇਸਨੂੰ ਇਨਵੋਲੂਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਇਹ ਬਹੁਤ ਤੇਜ਼ ਹੈ—ਲੀਨੀਅਰ ਸਮਾਂ ਜਟਿਲਤਾ O(n) ਜਿੱਥੇ n ਟੈਕਸਟ ਦੀ ਲੰਬਾਈ ਹੈ। ਆਮ ਟੈਕਸਟ (ਕੁਝ ਪੈਰਾਗ੍ਰਾਫ) ਲਈ, ਪ੍ਰੋਸੈਸਿੰਗ ਤੁਰੰਤ ਹੁੰਦੀ ਹੈ। ਬਹੁਤ ਲੰਬੇ ਟੈਕਸਟ (ਹਜ਼ਾਰਾਂ ਸ਼ਬਦ) ਲਈ ਵੀ, ਆਧੁਨਿਕ ਕੰਪਿਊਟਰ ਇਸਨੂੰ ਮਿਲੀਸਕਿੰਡ ਵਿੱਚ ਸੰਭਾਲ ਲੈਂਦੇ ਹਨ।
ਹਾਂ, ਪਰ ਤੁਹਾਨੂੰ ਇੱਕ ਕਸਟਮ ਫੰਕਸ਼ਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ ਕਿਉਂਕਿ ਕੋਈ ਬਿਲਟ-ਇਨ ਉਲਟ ਫੰਕਸ਼ਨ ਨਹੀਂ ਹੈ। ਐਕਸਲ VBA ਅਤੇ ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਾਗੂਕਰਨਾਂ ਲਈ ਉੱਪਰ ਦੇ ਕੋਡ ਉਦਾਹਰਣ ਭਾਗ ਨੂੰ ਦੇਖੋ।
ਨੁਥ, ਡੀ. ਈ. (1997). ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦਾ ਕਲਾ, ਵਾਲੀਅਮ 1: ਮੌਲਿਕ ਐਲਗੋਰਿਦਮ (3ਜਾ ਸੰਸਕਰਣ). ਐਡੀਸਨ-ਵੈਸਲੇ ਪ੍ਰੋਫੈਸ਼ਨਲ.
ਸੈਡਗਵਿਕ, ਆਰ., & ਵੇਨ, ਕੇ. (2011). ਐਲਗੋਰਿਦਮ (4ਥਾ ਸੰਸਕਰਣ). ਐਡੀਸਨ-ਵੈਸਲੇ ਪ੍ਰੋਫੈਸ਼ਨਲ.
ਯੂਨੀਕੋਡ ਕੌਂਸੋਰਟੀਅਮ. ਯੂਨੀਕੋਡ ਤਕਨੀਕੀ ਮਾਨਕ #18: ਯੂਨੀਕੋਡ ਨਿਯਮਿਤ ਅਭਿਵਿਅਕਤੀਆਂ. ਉਪਲਬਧ ਹੈ: https://unicode.org/reports/tr18/
MDN ਵੈਬ ਡੌਕਸ. ਸਟਰਿੰਗ ਮੈਥਡਸ ਸੰਦਰਭ. ਮੋਜ਼ੀਲਾ ਡਿਵੈਲਪਰ ਨੈਟਵਰਕ. ਉਪਲਬਧ ਹੈ: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String
ਕੋਰਮੈਨ, ਟੀ. ਐਚ., ਲੇਸਰਸਨ, ਸੀ. ਈ., ਰਿਵੈਸਟ, ਆਰ. ਐਲ., & ਸਟੀਨ, ਸੀ. (2009). ਐਲਗੋਰਿਦਮ ਦਾ ਪਰਿਚਯ (3ਜਾ ਸੰਸਕਰਣ). ਐਮਆਈਟੀ ਪ੍ਰੈਸ.
ਆਪਣੇ ਕਾਰਜ ਦੇ ਲਈ ਵਰਤਣ ਯੋਗ ਹੋਣ ਵਾਲੇ ਹੋਰ ਸੰਦੇਸ਼ ਦੀ ਖੋਜ ਕਰੋ