متن الٹنے والا: متن اور حروف کو فوری طور پر الٹیں

ٹیکسٹ انورٹر ٹول کیا ہے؟

ایک ٹیکسٹ انورٹر (جسے ریورس ٹیکسٹ ٹول بھی کہا جاتا ہے) متن کے حروف کے ترتیب کو الٹ دیتا ہے—"Hello World" کو "dlroW olleH" میں بدل دیتا ہے۔ آپ کو یہ حیرت انگیز طور پر مختلف کاموں میں مفید لگے گا، جیسے پالندروم کی جانچ کرنا یا ڈیزائن کے لیے مرر ٹیکسٹ بنانا۔

یہ ٹول رئیل ٹائم میں کام کرتا ہے: اپنا متن پیسٹ کریں یا ٹائپ کریں، اور آپ فوری طور پر اسے الٹا ہوا دیکھ سکیں گے۔ ٹیکسٹ انورژن میں دلچسپ بات یہ ہے کہ یہ مفہومی طور پر بہت آسان ہے (بس پیچھے سے پڑھیں)، پھر بھی یہ پروگرامنگ، انکرپشن، اور ٹیکسٹ تجزیے میں کچھ مفید اطلاقات کو سمتھ دیتا ہے۔

یہاں بات یہ ہے—میں نے ڈویلپرز کو ڈیبگنگ کے لیے، ڈیزائنرز کو بصری اثرات کے لیے، اور اساتذہ کو سٹرنگ مینیپولیشن سکھانے کے لیے ٹیکسٹ الٹنے کا استعمال کرتے ہوئے دیکھا ہے۔ ایک عام سناریو یہ ہے جب آپ پالندروم ڈیٹیکشن الگورتھم پر کام کر رہے ہوں اور اپنی منطق کو ٹیسٹ کیسز کے ساتھ تیزی سے تصدیق کرنا چاہتے ہیں۔

ٹیکسٹ انورٹر کا استعمال کیسے کریں

اس ریورس ٹیکسٹ ٹول کا استعمال تین آسان مراحل میں ہوتا ہے:

1. اپنا ٹیکسٹ درج کریں ان پٹ فیلڈ میں — براہ راست ٹائپ کریں یا کلپ بورڈ سے پیسٹ کریں
2. جادو دیکھیں جیسے ہی الٹا ٹیکسٹ فوری طور پر نیچے ظاہر ہو جائے گا (کسی بٹن پر کلک کرنے کی ضرورت نہیں)
3. نتیجہ کاپی کریں کاپی بٹن کے ذریعے ایک کلک میں

ٹول ہر چیز کو رئیل ٹائم میں پروسیس کرتا ہے، یعنی آپ تجربہ کر سکتے ہیں اور جیسے ٹائپ کرتے ہیں ویسے ہی نتائج دیکھ سکتے ہیں۔ یہ کسی بھی کریکٹر سیٹ پر کام کرتا ہے — انگریزی، ایموجی، خاص علامات، یہاں تک کہ جاپانی یا عربی جیسی زبانوں کے یونی کوڈ کریکٹرز۔

متن الٹ کرنے کا فارمولا اور الگورتھم

یہاں دیکھیں کہ متن الٹا کرنا ریاضی کی نظر سے کیسے کام کرتا ہے۔ $n$ طول کے سٹرنگ $S$ کے لیے جس میں حروف $S = c_1c_2c_3...c_n$ ہیں، الٹا سٹرنگ $S'$ اس طرح ہوگا:

$S' = c_nc_{n-1}c_{n-2}...c_1$

عملی طور پر، پروگرامر اس کو تین بنیادی طریقوں سے نافذ کرتے ہیں:

1. ایرے الٹا کرنا: سٹرنگ کو حروف میں تقسیم کریں، ایرے کو الٹ دیں، پھر واپس جوڑ دیں۔ سب سے زیادہ سیدھا اور پڑھنے میں آسان۔
2. دو-پوائنٹر تکنیک: دونوں سروں سے شروع کریں، حروف کو تبدیل کرتے ہوئے درمیان کی طرف بڑھیں۔ اگر مقام پر تبدیل کیا جا سکے تو میموری موثر۔
3. سٹیک پر مبنی طریقہ: حروف کو سٹیک پر ڈالیں (LIFO ڈھانچہ)، پھر انہیں باہر نکالیں۔ یہ فطری طور پر ترتیب الٹ دیتا ہے - اور یہ ڈیٹا سٹرکچرز کی تعلیم کے لیے بہترین مثال ہے۔

کارکردگی کی خصوصیات: متن الٹا کرنا $O(n)$ ٹائم کمپلیکسٹی (لینیئر) میں چلتا ہے کیونکہ ہر حرف کو بالکل ایک بار پروسیس کیا جاتا ہے۔ میموری کمپلیکسٹی بھی $O(n)$ ہے کیونکہ الٹے ہوئے سٹرنگ کو سٹور کرنے کی ضرورت ہوتی ہے۔ زیادہ تر عملی استعمال میں چند میگابائٹس سے کم متن کے لیے، کارکردگی فوری ہوتی ہے۔

ایک بات جس پر غور کرنا چاہیے - اگر آپ بہت بڑی متن کی فائلوں (جیسے الگز یا ڈیٹاسیٹس) کو الٹ رہے ہیں، تو آپ کو ایک بار میں سب کچھ میموری میں لوڈ کرنے سے بچنے کے لیے سٹریمنگ طریقوں پر غور کرنا چاہیے۔

متن الٹنے کا مرحلہ وار عمل

آئیے آپ کو بالکل ٹھیک سے بتاتے ہیں کہ الٹنے والا الگورتھم آپ کے متن کو کیسے پروسیس کرتا ہے:

1. خالی نتیجہ کنٹینر کے ساتھ شروع کریں
2. آخری حرف سے شروع کرتے ہوئے پیچھے کی طرف پڑھیں
3. نتیجے میں ہر حرف کو جوڑتے جائیں
4. جب پہلے حرف تک پہنچ جائیں تو رک جائیں
5. مکمل الٹے ہوئے سٹرنگ کو واپس کریں

عملی مثال "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 اسپیسز)۔

بہت طویل متن: انتہائی بڑے ان پٹس کے لیے (میگابائٹس کے متن کا خیال کریں)، آپ دستیاب میموری سے محدود ہیں۔ زیادہ تر جدید سسٹم اسے کئی MB تک آسانی سے ہینڈل کر سکتے ہیں، لیکن اگر آپ گیگابائٹ سائز کی فائلوں کو پروسیس کر رہے ہیں، تو آپ کو میموری میں سب کچھ لوڈ کرنے کے بجائے اسٹریمنگ حل چاہیے گا۔

ایک چیز جس پر میں نے غور کیا ہے: کمبائننگ حروف اور گراف کلسٹر کبھی کبھی غیر متوقع طریقے سے برتاؤ کر سکتے ہیں۔ مثال کے طور پر، سکن ٹون مڈیفائرز کے ساتھ ایموجی تکنیکی طور پر متعدد یونی کوڈ کوڈ پوائنٹس ہیں۔ زیادہ تر نفاذ اسے صحیح طریقے سے ہینڈل کرتے ہیں، لیکن اگر آپ پیچیدہ یونی کوڈ کے ساتھ کام کر رہے ہیں تو اپنے مخصوص استعمال کیس کے ساتھ اسے جانچنا فائدہ مند ہے۔

متن الٹنے کے عملی استعمال

آپ حیران ہو سکتے ہیں کہ متن الٹنا کتنی بار عملی استعمال میں آتا ہے۔ یہاں وہ منظرنامے ہیں جہاں میں نے اسے استعمال ہوتے دیکھا ہے:

پروگرامنگ اور ڈویلپمنٹ

پالندروم چیکنگ: جب آپ کو یہ تصدیق کرنی ہو کہ کیا ایک لفظ آگے اور پیچھے دونوں طرف ایک جیسا پڑھا جاتا ہے، آپ اسے الٹ کر کے موازنہ کرتے ہیں۔ مثال "racecar" → "racecar" (مماثل = پالندروم)۔

سٹرنگ الگورتھم پریکٹس: متن الٹنا ایک کلاسک کوڈنگ انٹرویو مسئلہ ہے جو آپ کی سٹرنگ مینی پلیشن اور بنیادی ڈیٹا سٹرکچرز کی سمجھ کو جانچتا ہے۔

سٹیک نفاذ ڈیمو: متن الٹنا LIFO (آخری اندر - پہلے باہر) رویے کو سکھانے کے لیے بالکل درست مثال ہے کیونکہ ایک سٹیک فطری طور پر آرڈر الٹ دیتا ہے۔

خفیہ نگاری اور سیکیورٹی

بنیادی انکوڈنگ: اپنے آپ میں محفوظ نہیں، متن الٹنا کبھی کبھی کثیر مرحلہ انکوڈنگ اسکیموں میں ایک طبقہ کے طور پر استعمال کیا جاتا ہے۔ یہ حقیقی خفیہ نگاری سے زیادہ ابہام پر مبنی ہے۔

چیلنج-جواب سسٹم: کچھ توثیقی سسٹم اپنی توثیق کے عمل میں الٹے سٹرنگز کا استعمال کرتے ہیں۔

تخلیقی اور تعلیمی اطلاقات

لفظ کھیل اور پہیلیاں: چیلنجز بنائیں جہاں کھلاڑی الٹے الفاظ کی شناخت کرتے ہیں یا پیغامات ڈیکوڈ کرتے ہیں۔ ایسکیپ رومز اور پہیلی ایپس میں مقبول۔

مرر لکھائی اثرات: ڈیزائنر لوگو، فنی اثرات یا عکاسی کو شامل کرنے والی بصری ڈیزائن کے لیے الٹے متن کا استعمال کرتے ہیں۔

تدریسی آلہ: مبتدیوں کو سٹرنگ مینی پلیشن سمجھاتے وقت، متن الٹنا اتنا آسان ہے کہ سمجھا جا سکے لیکن اتنا پیچیدہ کہ اترائی اور ایرے ہینڈلنگ جیسے اہم تصورات کو ظاہر کیا جا سکے۔

متن تجزیہ

زبانی تحقیق: زبان کے پیٹرن کا مطالعہ کرنے والے محققین کبھی کبھی متن کو آگے اور پیچھے دونوں طرف سے تجزیہ کرتے ہیں تاکہ ساخت کی خصوصیات کی شناخت کی جا سکے۔

پیٹرن کی نشاندہی: متن میں تناظر کی جانچ کرنا یا بڑے ڈیٹاسیٹ میں پھنسے ہوئے الٹے سیکوئنسز کو ڈھونڈنا۔

متن الٹنے کی مختلف قسمیں

کریکٹر-بائے-کریکٹر الٹنا آپ کا واحد آپشن نہیں ہے۔ اس پر منحصر کرتے ہوئے کہ آپ کیا حاصل کرنا چاہتے ہیں، یہ متبادل بہتر کام کر سکتے ہیں:

لفظ الٹنا: ہر لفظ کو سالم رکھیں لیکن ان کے آرڈر کو الٹ دیں۔ زبان سیکھنے اور کچھ متن پروسیسنگ کاموں کے لیے مفید۔

• مثال: "Hello World" → "World Hello"

جملے الٹنا: جملوں کے آرڈر کو الٹ دیں جبکہ ہر جملے کے اندر لفظوں کے آرڈر کو برقرار رکھیں۔

• مثال: "Hello World. How are you?" → "How are you? Hello World."

انتخابی الٹنا: صرف مخصوص حصوں کو اپنے معیار کے مطابق الٹ دیں - شاید صرف حروف علت، یا صرف 5 حروف سے لمبے الفاظ۔ لفظ پہیلیاں یا پیٹرن تجزیہ بنانے کے لیے بہترین۔

• مثال: "Hello World" میں صرف حروف علت الٹنا → "Hollo Werld"

صوتی الٹنا: زبانی تحقیق میں استعمال کیا جاتا ہے، یہ حروف کی بجائے آوازوں کو الٹتا ہے۔ پہلے صوتی تحریر کی ضرورت ہوتی ہے۔

بٹ سطح الٹنا: کریکٹرز کے بائنری نمائندگی کو الٹتا ہے۔ آپ اسے کچھ خفیہ نگاری کاموں اور کم سطح کی ڈیٹا مینی پلیشن میں دیکھیں گے۔

متن الٹنے کی تاریخ

متن الٹنا آپ کے خیال سے کہیں زیادہ پرانا ہے — قدیم تحریری نظاموں سے لے کر جدید کمپیوٹنگ تک۔

قدیم تحریر اور آئینہ متن

قدیم تہذیبوں نے کمپیوٹر سے بہت پہلے سے سمتی تحریر کی تجربہ کاری کی۔ یونانی اور مصریوں نے کبھی کبھی "بوسٹروفیڈون" انداز استعمال کیا، جہاں لائنیں متناوب سمت میں ہوتی تھیں — بائیں سے دائیں، پھر دائیں سے بائیں، جیسے بیل کھیت کو جوتتا ہے (جس کا مطلب "بوسٹروفیڈون" ہے)۔

لیونارڈو ڈا وینچی نے مشہور طور پر اپنی نوٹ بکوں کو آئینہ تحریر سے بھر دیا، جہاں متن الٹا ہوا نظر آتا ہے۔ مورخین بحث کرتے ہیں کہ آیا یہ خفیہ گی کے لیے تھا، یا اس لیے کہ وہ بائیں ہاتھی تھے اور یہ زیادہ آسان تھا، یا صرف سیاہی دھبہ روکنے کے لیے۔ جو بھی وجہ ہو، ان کی نوٹ بکیں ظاہر کرتی ہیں کہ متن الٹنا صدیوں سے انکوڈنگ تکنیک کے طور پر استعمال کیا جاتا رہا ہے۔

کمپیوٹنگ کا دور

جب کمپیوٹر 1950-60 کے دہائی میں ظاہر ہوئے، تو سٹرنگ مینی پلیشن ایک بنیادی پروگرامنگ مشق بن گیا۔ متن الٹنا ان کلاسیکی مسائل میں سے ایک تھا جو ہر پروگرامر نے سیکھا، ترتیب دینے اور تلاش کرنے کے ساتھ۔

جو اسے خاص دلچسپ بناتا تھا: اسٹیک ڈیٹا ڈھانچوں کا ترقی طبعی طور پر متن الٹنے سے جڑا ہوا تھا۔ اسٹیک کا LIFO (آخری اندر، پہلا باہر) رویہ خود بخود ترتیب الٹ دیتا ہے — "HELLO" کو کریکٹر بہ کریکٹر اسٹیک پر ڈالیں، انہیں نکالیں، اور آپ کو "OLLEH" ملے گا۔ یہ شاندار تعلق متن الٹنے کو ڈیٹا ڈھانچے سکھانے کے لیے ایک مثال بنا دیتا ہے۔

جدید اطبیقات

آج، آپ متن الٹنے والے الگورتھم کو پردے کے پیچھے کام کرتے ہوئے پائیں گے:

• کمپائلر اور پارسر: سنٹیکس تجزیہ اور اظہار کی تشخیص میں استعمال کیا جاتا ہے
• سٹرنگ میچنگ الگورتھم: بائیں سے دائیں پیٹرن پر کام کرنے والے بائر-مور الگورتھم کی طرح
• خفیہ نگاری: زیادہ پیچیدہ انکرپشن اسکیموں میں بلڈنگ بلاکس کے طور پر
• قدرتی زبان پروسیسنگ: زبانی پیٹرن کا تجزیہ، پالنڈروم کی نشاندہی، اور متن کی ساخت کا مطالعہ

الگورتھم کی سادگی (یہ پہلا ہے جو آپ سیکھتے ہیں) اس کی عملی افادیت کے ساتھ اس بات کو یقینی بناتا ہے کہ یہ اس کے پہلے نفاذ کے دہائیوں بعد بھی متعلقہ رہے۔

کوڈ کی مثالیں: مختلف زبانوں میں متن الٹ کرنا

یہاں مشہور پروگرامنگ زبانوں میں متن الٹ کرنے کا طریقہ دکھایا گیا ہے۔ ہر مثال میں بنیادی الگورتھم اور عملی استعمال شامل ہے:

1' ایکسل 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("Hello, World!")
15

1def invert_text(input_text):
2    """سٹرنگ میں حروف کا ترتیب الٹا کریں۔"""
3    return input_text[::-1]
4
5## مثالی استعمال:
6
7اصل_متن = "ہیلو، دنیا!"
8الٹا_متن = الٹا_متن(اصل_متن)
9پرنٹ(f"اصل: {اصل_متن}")
10پرنٹ(f"الٹا: {الٹا_متن}")
11
12# یونی کوڈ حروف کو ہینڈل کرنا
13یونی_کوڈ_متن = "こんにちは世界! 🌍"
14الٹا_یونی_کوڈ = الٹا_متن(یونی_کوڈ_متن)
15پرنٹ(f"اصل یونی کوڈ: {یونی_کوڈ_متن}")
16پرنٹ(f"الٹا یونی کوڈ: {الٹا_یونی_کوڈ}")
17

1function 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)}`);
18

1public 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}
20

1invert_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")
11

1function 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);
11

1#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}
23

1def 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}"
16

1<?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?>
18

1fn 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}
18

1using 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}
30

1package 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}
28

1func 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 MB سے کم) میں، یہ نگنی قابل غور نہیں ہے۔ بڑے متون کے لیے، آپ عارضی طور پر میموری استعمال کو دگنا کر رہے ہیں۔

موقع پر الٹ کرنا: C، C++، اور Rust جیسی زبانیں آپ کو کیریکٹر اریز کو سیدھے میموری میں بغیر کاپی بنائے الٹنے کی اجازت دیتی ہیں۔ یہ میموری استعمال کو آدھا کر دیتا ہے لیکن صرف تبدیل کرنے والے متون کے ساتھ کام کرتا ہے۔ بہت سی زبانیں (Python، JavaScript، Java) غیر تبدیل کرنے والے متون استعمال کرتی ہیں، اس لیے آپ کو نئی بنانی پڑتی ہے۔

یونی کوڈ ہینڈلنگ: یہاں چیزیں پیچیدہ ہو جاتی ہیں۔ ملٹی-بائٹ یونی کوڈ کیریکٹرز کو صحیح طریقے سے ہینڈل کرنے کی ضرورت ہے ورنہ آپ انکوڈنگ کو خراب کر دیں گے۔ زیادہ تر جدید زبان کی معیاری لائبریریاں اسے صحیح طریقے سے ہینڈل کرتی ہیں، لیکن اگر آپ کم سطح کا کوڈ لکھ رہے ہیں یا بائٹ اریز کے ساتھ سیدھا کام کر رہے ہیں، تو محتاط رہیں۔ ایموجی اور غیر لاطینی اسکرپٹس کے ساتھ جانچ کریں۔

بڑی فائلوں کے لیے سٹریمنگ: اگر آپ گیگابائٹ سائز کی الگ فائلوں یا ڈیٹاسیٹس کو الٹ رہے ہیں، تو سب کچھ میموری میں لوڈ نہ کریں۔ سٹریمنگ مقصد استعمال کریں - آخر سے چنکس پڑھیں، جیسے جیسے لکھیں۔ یونی کوڈ ٹیکنیکل سٹینڈرڈ #18 کے مطابق، گراف کلسٹر ہینڈلنگ کو صحیح متن سرحد کی نشاندہی کے لیے خاص توجہ کی ضرورت ہے۔

متوازی سازی: انتہائی طویل متون کے لیے، آپ نظریاتی طور پر الٹ کرنے کو متوازی بنا سکتے ہیں (چنکس میں تقسیم کریں، ہر ایک کو الٹیں، جوڑیں)۔ عملی طور پر، اوورہیڈ عام طور پر اس کے لائق نہیں ہوتا جب تک کہ آپ بہت بڑے ڈیٹاسیٹس کے ساتھ نہ کام کر رہے ہوں اور کمپیوٹ وسائل موجود نہ ہوں۔

اکثر پوچھے جانے والے سوالات

میں آن لائن ٹیکسٹ کیسے الٹ کر سکتا ہوں؟

بس اپنا ٹیکسٹ اوپر کے ان پٹ فیلڈ میں پیسٹ یا ٹائپ کریں۔ ٹول خود بخود اسے حقیقی وقت میں الٹ کر دیتا ہے - کسی بٹن کو دبانے کی ضرورت نہیں۔ نتیجہ کو ایک کلک میں کاپی کریں۔

ٹیکسٹ الٹنے اور الٹے الفاظ میں کیا فرق ہے؟

ٹیکسٹ الٹنا (حرف الٹنا) انفرادی حروف کو الٹ دیتا ہے: "Hello World" → "dlroW olleH"۔ الفاظ الٹنا ہر لفظ کو سلامت رکھتا ہے لیکن ان کے ترتیب کو الٹ دیتا ہے: "Hello World" → "World Hello"۔ یہ ٹول حرف الٹنا کرتا ہے۔

کیا یہ ٹول ایموجی اور یونی کوڈ حروف کو سنبھال سکتا ہے؟

جی ہاں۔ ٹول تمام یونی کوڈ حروف کو درست طریقے سے سنبھالتا ہے، جن میں ایموجی، چینی/جاپانی/کوریائی ٹیکسٹ، عربی اسکرپٹ، خاص علامات، اور مرکب حروف شامل ہیں۔ "こんにちは 🌍" کے ساتھ آزمائیں۔

کیا الٹا ٹیکسٹ میرر رائٹنگ کے برابر ہے؟

یہ متعلقہ ہیں لیکن ایک جیسے نہیں۔ حرف الٹنا (جو یہ ٹول کرتا ہے) بس حروف کے ترتیب کو الٹ دیتا ہے۔ میرر رائٹنگ حروف کو افقی طور پر الٹ دیتی ہے تاکہ وہ میرر کی عکاسی کی طرح نظر آئیں۔ میرر رائٹنگ کو پڑھنے کے لیے، آپ کو اصل میں میرر یا افقی الٹ کرنے کی ضرورت ہوتی ہے۔

میں ٹیکسٹ کو کیوں الٹنا چاہوں گا؟

عام استعمال میں شامل ہیں: پالنڈروم کی جانچ، پہیلیوں کے لیے سادہ انکوڈنگ، پروگرامنگ کے لیے ٹیسٹ ڈیٹا تیار کرنا، فنی ٹیکسٹ افیکٹس بنانا، سٹرنگ الگورتھم سکھانا، اور ٹیکسٹ پروسیسنگ کوڈ کی ڈیبگنگ۔

کیا ٹیکسٹ کو دوبارہ الٹنے سے اصل ٹیکسٹ واپس آ جاتا ہے؟

جی ہاں۔ ٹیکسٹ الٹنا اپنا الٹا آپریشن ہے۔ اگر آپ "Hello" کو "olleH" میں الٹتے ہیں، پھر "olleH" کو الٹتے ہیں، تو آپ کو "Hello" واپس مل جاتا ہے۔ ریاضی میں، اسے انوولوشن کہا جاتا ہے۔

ٹیکسٹ الٹنے میں کتنا وقت لگتا ہے؟

یہ بہت تیز ہے - خطی وقت کی پیچیدگی O(n) جہاں n ٹیکسٹ کی لمبائی ہے۔ عام ٹیکسٹ (کچھ پیراگراف) کے لیے، پروسیسنگ فوری ہے۔ بہت طویل ٹیکسٹ (ہزاروں الفاظ) کے لیے بھی، جدید کمپیوٹر اسے مائیکرو سیکنڈ میں سنبھال لیتے ہیں۔

کیا میں ایکسل یا گوگل شیٹس میں ٹیکسٹ الٹ سکتا ہوں؟

جی ہاں، لیکن آپ کو ایک مخصوص فنکشن کی ضرورت ہے کیونکہ کوئی بھی بلٹ-ان الٹنے والا فنکشن نہیں ہے۔ ایکسل VBA اور دیگر پروگرامنگ کی مثالوں کے لیے اوپر کے کوڈ کے حصے کو دیکھیں۔

تکنیکی حوالے

1. نوتھ، ڈی. ای. (1997). کمپیوٹر پروگرامنگ کی فن، جلد 1: بنیادی الگورزم (3rd ایڈیشن). ایڈیسن-ویسلی پروفیشنل.

2. سیڈجویک، آر.، & ویین، کے. (2011). الگورزم (4th ایڈیشن). ایڈیسن-ویسلی پروفیشنل.

3. یونی کوڈ کنسورشیم. یونی کوڈ تکنیکی معیار #18: یونی کوڈ باقاعدہ اظہار. دستیاب ہے: https://unicode.org/reports/tr18/

4. MDN ویب دستاویزات. سٹرنگ میتھڈز حوالہ. موزیلا ڈویلپر نیٹ ورک. دستیاب ہے: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String

5. کورمین، ٹی. ایچ.، لیسرسن، سی. ای.، رائیوسٹ، آر. ایل.، & سٹین، سی. (2009). الگورزم کی تعارف (3rd ایڈیشن). MIT پریس.