جاوا میں ریورس سٹرنگ: مختلف طریقوں سے سٹرنگ کو ریورس کرنا سیکھنا

کیا الگورتھم جانے بغیر اچھا پروگرامر بننا ممکن ہے؟ بہت، بہت متنازعہ۔ جی ہاں، آپ ہماری آؤٹ سورسنگ کمپنیوں میں نوکری تلاش کر سکتے ہیں، کیونکہ انٹرویو کے دوران وہ زیادہ تر ٹیکنالوجی کے بارے میں سوالات کرتے ہیں۔ لیکن کیا آپ ایک اچھے ماہر بنیں گے اگر آپ کے فیصلے بیساکھیوں سے بھرے ہوں؟ اگر آپ زیادہ سنجیدہ غیر ملکی کمپنی میں جانا چاہتے ہیں، تو آپ کو انٹرویوز کا سامنا کرنا پڑے گا جو بنیادی طور پر الگورتھم پر مرکوز ہیں۔ ایک یا دوسرے طریقے سے، یہ سب سے بنیادی الگورتھم کو اپنانے کے قابل ہے، کیونکہ الگورتھم ایک پروگرامر کا دوست ہوتا ہے ۔ آج ہم ان میں سے کسی ایک عنوان کو چھوئیں گے اور سٹرنگ کو ریورس کرنے کے طریقوں پر بات کریں گے۔ یہاں سب کچھ آسان ہے۔ سٹرنگ کو ریورس کرنا سٹرنگ کو پیچھے کی طرف لے جا رہا ہے۔ مثال کے طور پر: JavaRush forever -> reverof hsuRavaJ تو، آپ جاوا میں اسٹرنگ کو کیسے ریورس کرسکتے ہیں؟

1. StringBuilder/StringBuffer

سب سے عام اور آسان طریقہ StringBuilder/StringBuffer استعمال کرنا ہے ۔

public static String reverseString(String str) {
  return new StringBuilder(str).reverse().toString();
}

بہترین حل = آسان۔ جب یہ پوچھا گیا کہ جاوا میں سٹرنگ کو کیسے ریورس کیا جائے تو یہ پہلی چیز ہے جو ذہن میں آنی چاہیے۔ لیکن ہم نے پہلے الگورتھم کے بارے میں بات کی تھی، کیا ہم نے نہیں؟ آئیے ان حلوں پر ایک نظر ڈالتے ہیں جو باکس سے باہر نہیں ہیں۔

2. صف حل

public static String reverseString(String str) {
  char[] array = str.toCharArray();
  String result = "";
  for (int i = array.length - 1; i >= 0; i--) {
     result = result + array[i];
  }
  return result;
}

ہم toCharArray طریقہ استعمال کرکے اپنی سٹرنگ کو ایک صف میں تبدیل کرتے ہیں ۔ آئیے اس سرے کے ذریعے اس کے سرے سے ایک لوپ چلائیں ، راستے میں نتیجے میں آنے والی سٹرنگ میں حروف شامل کریں۔

3. charAt کے ساتھ حل

public static String reverseString(String str) {
  String result = "";
  for (int i = 0; i < str.length(); i++) {
     result = str.charAt(i) + result;
  }
  return result;
}

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

4. اسٹیک کے ساتھ حل

اسٹیک کلاس کو ایک طویل عرصے سے استعمال نہیں کیا گیا ہے، اور اسے متروک سمجھا جاتا ہے، لیکن اس کے باوجود، حوالہ کے لیے، اس کا استعمال کرتے ہوئے کسی حل کو دیکھنا مفید ہو گا:

public static String reverseString(String str) {
  Stack<Character> stack = new Stack<>();
  String result = "";
  for (Character character : str.toCharArray()) {
     stack.add(character);
  }
  while (!stack.isEmpty()) {
     result = result + stack.pop();
  }
  return result;
}

یہاں ایک بار پھر ہم toCharArray کا استعمال کرتے ہیں تاکہ سٹرنگ کو ایک صف میں تقسیم کیا جا سکے اور یہ سب کچھ اپنے اسٹیک میں ایک عام قسم کے Character کے ساتھ رکھا جائے ۔ اگلا، ہم اسٹیک کے اوپر سے عناصر لینا شروع کرتے ہیں۔ LIFO ڈھانچے کے طور پر اسٹیک کی نوعیت کی وجہ سے - L ast I n F irst O ut (پہلے میں، آخری باہر)، عناصر کو پیچھے کی طرف لے جایا جائے گا اور نتیجہ آنے والی قطار میں محفوظ کیا جائے گا۔

5. تکرار بذریعہ حل

تقریباً ہر الگورتھم کا مسئلہ تکرار کا استعمال کرتے ہوئے حل کیا جا سکتا ہے۔ اور یہاں ہم اس کے بغیر بھی نہیں کر سکتے۔ یا ان کے بغیر بھی۔ بہر حال، آج ہم تکرار کو حل کرنے کے صرف ایک طریقہ پر نہیں بلکہ کئی طریقوں پر غور کریں گے۔

• طریقہ ایک

  public static String reverseString(String str) {
    String rightStr;
    String leftStr;
    int length = str.length();
  
    if (length <= 1) {
       return str;
    }
  
    leftStr = str.substring(0, length / 2);
    rightStr = str.substring(length / 2, length);
  
    return reverseString(rightStr) + reverseString(leftStr);
  }

  ہم آنے والی سٹرنگ کو دو برابر حصوں میں تقسیم کرنے کے لیے rightStr اور leftStr متغیرات کا استعمال کرتے ہیں۔ اگلا، اس تقسیم کا استعمال کرتے ہوئے، ہم سٹرنگ کو سب سے چھوٹے قابل تقسیم حصوں (1 کریکٹر) میں تقسیم کرتے ہیں۔ اس کے بعد، تکرار ٹوٹنا شروع ہو جاتی ہے، حروف کو مخالف ترتیب میں لوٹاتا ہے (وہ جو دائیں طرف تھے بائیں طرف رکھے گئے تھے؛ جو بائیں طرف تھے وہ دائیں طرف رکھے گئے تھے)

  ہمیں یہ نہیں بھولنا چاہیے کہ ہر تکرار ایک طریقہ کے لیے ایک سے زیادہ کال ہے، اور اس کے نتیجے میں، وسائل کا کافی خرچ ہوتا ہے۔ ٹھیک ہے، اگر ہم ایک ناقابل حصول خارجی حالت کے ساتھ تکرار کے بارے میں بات کر رہے ہیں، تو یہ انفینٹی اور StackOverflowError کا راستہ ہے۔

• طریقہ دو

  یہاں ہمیں طریقہ کار میں ایک اضافی دلیل کی ضرورت ہے۔

  جب یہ طریقہ چلایا جاتا ہے، تو اسے -1 کی تار کی لمبائی دی جاتی ہے:

  String str = "JavaRush forever";
  System.out.println(reverseString(str, str.length()-1));

  اور طریقہ خود:

  public static String reverseString(String str, int index) {
    if(index == 0){
       return str.charAt(0) + "";
    }
  
    char letter = str.charAt(index);
    return letter + reverseString(str, index-1);
  }

  ہمارا انڈیکس ایک اشارے کے طور پر کام کرتا ہے کہ ہم اب کون سا قطار عنصر استعمال کریں گے (اور ہم عناصر کو آخر سے استعمال کریں گے)۔

  لہذا، جب انڈیکس پہلے عنصر تک پہنچ جاتا ہے تو ہم باہر نکلنے کی شرائط طے کرتے ہیں۔

ہم لیٹر انڈیکس کا استعمال کرتے ہوئے حاصل کردہ اقدار کو طریقہ کار کے پچھلے عمل کے نتیجے کے ساتھ شامل کرتے ہیں اور نتیجہ واپس کرتے ہیں۔

• طریقہ تین

  public static String reverseString(String str) {
    if (str.length() <= 1) {
       return str;
    }
    return reverseString(str.substring(1)) + str.charAt(0);
  }

  یہ طریقہ بنیادی طور پر تکراری طریقوں میں سب سے آسان ہے۔ اور جیسا کہ ہمیں یاد ہے، سادہ = بہترین۔

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

6. XOR کا استعمال

XOR ایک منطقی بٹ وائز آپریشن ہے۔ دو متغیرات کی صورت میں، آپریشن کا نتیجہ درست ہے اگر اور صرف اس صورت میں جب ایک دلیل درست ہو اور دوسرا غلط ہو۔ آپ اس مضمون میں بٹ وائز آپریشنز کے بارے میں مزید پڑھ سکتے ہیں ۔ اگلا حل اس حقیقت پر انحصار کرے گا کہ:

(A XOR B) XOR B = A
(A XOR B) XOR A = B

طریقہ کیسا نظر آئے گا:

public static String reverseString(String str) {
  char[] arr = str.toCharArray();
  int low = 0;
  int high = arr.length - 1;
  String result = "";
  while (low < high) {
     arr[low] = (char) (arr[low] ^ arr[high]);
     arr[high] = (char) (arr[low] ^ arr[high]);
     arr[low] = (char) (arr[low] ^ arr[high]);
     low++;
     high--;
  }
  for (int i = 0; i < arr.length; i++) {
     result = result + arr[i];
  }
  return result;
}

آئیے معلوم کریں کہ یہاں کیا ہو رہا ہے۔ ہم آنے والی تار سے ایک صف بناتے ہیں۔ ہم دو متغیرات بناتے ہیں، low اور high ، جو صفوں کو عبور کرنے کے لیے انڈیکس کو اسٹور کرتے ہیں۔ اس کے مطابق، ایک شروع سے آخر تک چلے گا - ہم نے اس کی قدر 0 سیٹ کی، دوسرا - آخر سے شروع تک، ہم نے اسے arr.length - 1 سیٹ کیا ۔ ہم ایک لوپ داخل کرتے ہیں جو اس وقت تک چلے گا جب تک انڈیکس ہائی کم سے زیادہ ہو ۔ یہیں سے تفریحی چیزیں ہونے لگتی ہیں - خصوصی OR کا استعمال۔ آئیے ایک مثال کے طور پر x اور y کو دیکھیں ۔ فرض کریں arr[high] = 'x'؛ اس کا بائنری کوڈ ہوگا 1 1 1 1 0 0 0 اس وقت arr[high] = 'n'؛ بائنری کوڈ - 1 1 0 1 1 1 0 لوپ میں XOR آپریشنز میں ہمارے پاس کیا ہوگا:

1. arr[low] = (char) (arr[low] ^ arr[high])؛

   
   arr[low] = 1 1 0 1 1 1 0
   arr[high] =1 1 1 1 0 0 0
   arr[low] = 0 0 1 0 1 1 0

2. arr[high] = (char) (arr[low] ^ arr[high])؛

   
   arr[low] =  0 0 1 0 1 1 0
   arr[high] = 1 1 1 1 0 0 0
   arr[high] = 1 1 0 1 1 1 0

3. arr[low] = (char) (arr[low] ^ arr[high])؛

   
   arr[low] =  0 0 1 0 1 1 0
   arr[high] = 1 1 0 1 1 1 0
   arr[low] =  1 1 1 1 0 0 0

نتیجے کے طور پر، ان آپریشنز کی بدولت، ہم نے دو صفوں کی قدروں کو تبدیل کیا۔ arr[high] سرنی کے آخر سے اتنے ہی عناصر ہیں جتنے arr[low] شروع سے ہیں۔ لہذا، ہم صرف عناصر کو ان انڈیکس کے ساتھ تبدیل کرتے ہیں۔ مثال کے طور پر، جملے کے پہلے عمل پر "جاوارش ہمیشہ کے لیے" J اور r کو تبدیل کیا جائے گا، دوسرے پر - a اور e ، وغیرہ۔ اگر ہمارے پاس حروف کی ایک طاق تعداد ہے، تو جب ہم اس عنصر تک پہنچیں گے جو درمیانی، ہمیں لوپ سے باہر پھینک دیا جائے گا (یعنی درمیانی عنصر کو تبدیل کرنے کی ضرورت نہیں ہے)۔ اگر یہ برابر ہے، تو ہمیں تمام عناصر پر کارروائی کرنے کے بعد باہر پھینک دیا جائے گا۔ ٹھیک ہے، اس کے بعد ہم ایک ریگولر لوپ میں جاتے ہیں اور ارے عناصر سے ایک سٹرنگ بناتے ہیں۔