جاوا ۾ ريورس اسٽرنگ: مختلف طريقن سان اسٽرنگ کي ريورس ڪرڻ سکڻ

ڇا اهو ممڪن آهي ته هڪ سٺو پروگرامر بڻجڻ کان سواءِ الگورٿم ڄاڻڻ؟ تمام گهڻو، تمام گهڻو تڪراري. ها، توهان اسان جي آئوٽ سورسنگ ڪمپنين ۾ نوڪري ڳولي سگهو ٿا، ڇو ته انٽرويو دوران اهي سوال پڇندا آهن اڪثر ٽيڪنالاجي بابت. پر ڇا توهان سٺو ماهر هوندا جيڪڏهن توهان جا فيصلا ڪچين سان ڀريل هوندا؟ جيڪڏهن توهان هڪ وڌيڪ سنجيده پرڏيهي ڪمپني ڏانهن وڃڻ چاهيو ٿا، توهان انٽرويو سان منهن ڪنداسين جيڪي بنيادي طور تي الگورتھم تي مرکوز آهن. هڪ طريقو يا ٻيو، اهو سڀ کان وڌيڪ بنيادي الگورتھم کي اپنائڻ جي قابل آهي، ڇاڪاڻ ته هڪ الگورٿم هڪ پروگرامر جو دوست آهي . اڄ اسان انهن مان هڪ موضوع تي رابطو ڪنداسين ۽ هڪ تار کي ريورس ڪرڻ جي طريقن تي بحث ڪنداسين. هتي سڀ ڪجھ سادو آهي. هڪ تار کي ريورس ڪرڻ، تار کي پوئتي موٽڻ آهي. مثال طور: 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. چارٽ سان حل

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 اسٽرنگ کي هڪ صف ۾ ورهائڻ لاءِ ۽ اهو سڀ اسان جي اسٽيڪ ۾ هڪ عام قسم جي ڪردار سان . اڳيون، اسان اسٽيڪ جي چوٽي کان عناصر وٺڻ شروع ڪندا آهيون. LIFO ساخت جي طور تي اسٽيڪ جي نوعيت جي ڪري - L ast I n F irst O ut (پهرين اندر، آخري آئوٽ)، عناصر کي پوئتي موٽايو ويندو ۽ نتيجو نتيجو قطار ۾ ذخيرو ڪيو ويندو.

5. ورجائي ذريعي حل

تقريبن هر الگورٿم مسئلو حل ڪري سگهجي ٿو recursion استعمال ڪندي. ۽ هتي اسان هن کان سواء نٿا ڪري سگهون. يا ان کان سواءِ به. سڀ کان پوء، اڄ اسان تي غور ڪنداسين صرف هڪ طريقي سان ٻيهر حل ڪرڻ جو، پر ڪيترن ئي.

• طريقو هڪ

  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 هڪ منطقي bitwise آپريشن آهي. ٻن متغيرن جي صورت ۾، آپريشن جو نتيجو صحيح آھي جيڪڏھن ۽ صرف جيڪڏھن دليلن مان ھڪڙو سچو آھي ۽ ٻيو غلط آھي. توھان ھن مضمون ۾ bitwise آپريشن بابت وڌيڪ پڙھي سگھو ٿا . ايندڙ حل ان حقيقت تي ڀروسو ڪندو ته:

(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;
}

اچو ته سمجهون ته هتي ڇا ٿي رهيو آهي. اسان ايندڙ اسٽرنگ مان هڪ صف ٺاهيندا آهيون. اسان ٻه متغير ٺاهيندا آهيون، گهٽ ۽ اعلي ، جيڪي اسٽوري انڊيڪس کي ترتيب ڏيڻ لاءِ. ان مطابق، ھڪڙو شروع کان آخر تائين ھلندو - اسان ان کي قيمت ڏيون ٿا 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 وغيره. جيڪڏهن اسان وٽ اکرن جو بي جوڙ تعداد آهي، ته پوءِ جڏهن اسان ان عنصر تائين پهچون ٿا جيڪو ان ۾ آهي. وچ ۾، اسان کي لوپ مان ڪڍيو ويندو (يعني وچين عنصر کي تبديل ڪرڻ جي ڪا ضرورت ناهي). جيڪڏهن اهو به آهي، اسان سڀني عناصر کي پروسيس ڪرڻ کان پوء ٻاهر ڪڍيو ويندو. خير، ان کان پوء اسان هڪ باقاعده لوپ ۾ وڃون ٿا ۽ صف جي عناصر مان هڪ اسٽرنگ ٺاهي.