جاوا ڈویلپر کے انٹرویوز سے سوالات اور جوابات کا تجزیہ۔ حصہ 13

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

111. تھریڈز کے درمیان ڈیٹا کا تبادلہ کیسے کیا جائے؟

دھاگوں کے درمیان ڈیٹا کا تبادلہ کرنے کے لیے، آپ بہت سے مختلف طریقوں اور ذرائع کا استعمال کر سکتے ہیں: مثال کے طور پر، ایٹم متغیرات، مطابقت پذیر مجموعہ، اور ایک سیمفور استعمال کریں۔ لیکن اس مسئلے کو حل کرنے کے لیے، میں ایک مثال دیتا ہوں Exchanger ۔ ایکسچینجر کنکرنٹ پیکیج سے ایک ہم آہنگی کی کلاس ہے جو ایک مشترکہ مطابقت پذیری پوائنٹ بنا کر دھاگوں کے جوڑے کے درمیان عناصر کے تبادلے کی سہولت فراہم کرتی ہے۔ اس کا استعمال دو تھریڈز کے درمیان ڈیٹا کے تبادلے کو آسان بناتا ہے۔ اس کے کام کرنے کا طریقہ کافی آسان ہے: یہ اپنے exchange() طریقہ کو کال کرنے کے لیے دو الگ الگ تھریڈز کا انتظار کرتا ہے ۔ ان کے درمیان ایک تبادلے کے نقطہ کی طرح کچھ پیدا ہوتا ہے: پہلا دھاگہ اپنی چیز رکھتا ہے اور بدلے میں دوسرے کا اعتراض وصول کرتا ہے، اور بعد میں، بدلے میں، پہلے کا اعتراض حاصل کرتا ہے اور اپنا رکھتا ہے. یعنی، پہلا تھریڈ ایکسچینج() طریقہ استعمال کرتا ہے اور اس وقت تک بیکار رہتا ہے جب تک کہ دوسرا تھریڈ ایکسچینج() طریقہ کو اسی آبجیکٹ پر کال نہ کرے اور ان کے درمیان ڈیٹا کا تبادلہ نہ ہو۔ مثال کے طور پر، تھریڈ کلاس کے مندرجہ ذیل نفاذ پر غور کریں :

public class CustomThread extends Thread {
 private String threadName;
 private String message;
 private Exchanger<String> exchanger;

 public CustomThread(String threadName, Exchanger<String> exchanger) {
   this.threadName = threadName;
   this.exchanger = exchanger;
 }

 public void setMessage(final String message) {
   this.message = message;
 }

 @Override
 public void run() {
   while (true) {
     try {
       message = exchanger.exchange(message);
       System.out.println(threadName + " поток получил сообщение: " + message);
       Thread.sleep(1000);
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }
}

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

Exchanger<String> exchanger = new Exchanger<>();
CustomThread first = new CustomThread("Первый ", exchanger);
first.setMessage("Сообщение первого потока");
CustomThread second = new CustomThread("Второй", exchanger);
second.setMessage("Сообщение второго потока");
first.start();
second.start();

کنسول دکھائے گا: اس کا مطلب ہے کہ دھاگوں کے درمیان ڈیٹا کا تبادلہ کامیاب ہے۔

112. تھریڈ کلاس اور رن ایبل انٹرفیس میں کیا فرق ہے؟

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

1. Thread سے inherit کریں ، رن میتھڈ کو اوور رائڈ کریں، پھر اس آبجیکٹ کو بنائیں اور start() طریقہ کے ذریعے تھریڈ کو شروع کریں ۔

2. Runnable کو ایک مخصوص کلاس میں لاگو کریں ، اس کے run() طریقہ کو نافذ کریں ، اور پھر ایک Thread آبجیکٹ بنائیں، رن ایبل انٹرفیس کے اس آبجیکٹ کے نفاذ کو اس کے کنسٹرکٹر کو تفویض کریں ۔ ٹھیک ہے، آخر میں، start() طریقہ استعمال کرتے ہوئے Thread آبجیکٹ کو لانچ کریں ۔

کیا افضل ہے؟ آئیے تھوڑا سوچتے ہیں:

• جب آپ رن ایبل انٹرفیس کو لاگو کرتے ہیں ، تو آپ تھریڈ کے رویے کو تبدیل نہیں کرتے ہیں۔ بنیادی طور پر آپ دھاگے کو چلانے کے لیے کچھ دے رہے ہیں۔ اور یہ ہماری ترکیب ہے، جس کے نتیجے میں ایک اچھا نقطہ نظر سمجھا جاتا ہے.

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

• رن ایبل کا استعمال آپ کو ٹاسک ایگزیکیوشن کو تھریڈ کنٹرول لاجک سے منطقی طور پر الگ کرنے کی اجازت دیتا ہے۔

• جاوا میں، صرف ایک ہی وراثت ممکن ہے، لہذا صرف ایک طبقے کو بڑھایا جا سکتا ہے۔ ایک ہی وقت میں، قابل توسیع انٹرفیس کی تعداد لامحدود ہے (اچھی طرح سے، بالکل لامحدود نہیں، لیکن 65535 ، لیکن آپ کو اس حد تک پہنچنے کا امکان نہیں ہے)۔

ٹھیک ہے، کیا استعمال کرنا بہتر ہے اس کا فیصلہ آپ پر ہے ^^

113. T1، T2 اور T3 تھریڈز ہیں۔ ان کو ترتیب وار کیسے نافذ کیا جائے؟

سب سے پہلی اور آسان چیز جو ذہن میں آتی ہے وہ ہے join() طریقہ استعمال کرنا ۔ یہ موجودہ تھریڈ (جسے طریقہ کہا جاتا ہے) پر عمل درآمد کو اس وقت تک معطل کر دیتا ہے جب تک کہ وہ تھریڈ جس پر طریقہ کہلاتا تھا اس پر عمل درآمد ختم نہ ہو جائے۔ آئیے اپنا اپنا تھریڈ نفاذ بنائیں:

public class CustomThread extends Thread {
private String threadName;

 public CustomThread(final String  threadName){
   this.threadName = threadName;
 }

 @Override
 public void run() {
   System.out.println(threadName + " - начал свою работу");
   try {
     // происходит некая логика
     Thread.sleep(1000);
   } catch (InterruptedException e) {
     e.printStackTrace();
   }

   System.out.println(threadName + " - закончил свою работу");
 }
}

آئیے اس طرح کے تین تھریڈز ایک ایک کرکے join() کا استعمال کرتے ہوئے شروع کرتے ہیں ۔

CustomThread t1 = new CustomThread("Первый поток");
t1.start();
t1.join();
CustomThread t2 = new CustomThread("Второй поток");
t2.start();
t2.join();
CustomThread t3 = new CustomThread("Третий поток");
t3.start();
t3.join();

کنسول آؤٹ پٹ: اس کا مطلب ہے کہ ہم نے اپنا کام مکمل کر لیا ہے۔ اگلا، ہم جونیئر سطح پر براہ راست عملی کاموں کی طرف بڑھتے ہیں ۔

عملی کام

114. میٹرکس ڈائیگنل سم (لیٹ کوڈ کا مسئلہ)

حالت: مرکزی اخترن پر تمام عناصر اور اضافی اخترن پر تمام عناصر کے مجموعہ کا حساب لگائیں جو مرکزی اخترن کا حصہ نہیں ہیں۔ 1. فارم کے میٹرکس کے ساتھ: mat = [[1,2,3], [4,5,6], [7,8,9]] آؤٹ پٹ ہونا چاہئے - 25 2. میٹرکس کے ساتھ - mat = [[1,1,1,1], [1,1,1,1], [1,1,1,1], [1,1,1,1]] آؤٹ پٹ ہونا چاہئے - 8 3. کے ساتھ a matrix - mat = [[ 5]] نتیجہ یہ ہونا چاہئے - 5 پڑھنے کو روکیں اور اپنے فیصلے پر عمل کریں۔ میرا حل مندرجہ ذیل ہوگا:

public static int countDiagonalSum(int[][] matrix) {
 int sum = 0;
 for (int i = 0, j = matrix.length - 1; i < matrix.length; i++, j--) {
   sum += matrix[i][i];
   if (j != i) {
     sum += matrix[i][j];
   }
 }
 return sum;
}

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

int[][] arr1 = {
   {1, 2, 3},
   {4, 5, 6},
   {7, 8, 9}};
System.out.println(countDiagonalSum(arr1));

int[][] arr2 = {
   {1, 1, 1, 1},
   {1, 1, 1, 1},
   {1, 1, 1, 1},
   {1, 1, 1, 1}};
System.out.println(countDiagonalSum(arr2));

int[][] arr3 = {{5}};
System.out.println(countDiagonalSum(arr3));

کنسول آؤٹ پٹ:

115. Move Zeroes (Letcode چیلنج)

حالت: ایک عددی صف میں، تمام 0 کو آخر تک لے جائیں، غیر صفر عناصر کی نسبتی ترتیب کو برقرار رکھتے ہوئے۔ 1. ایک صف کے ساتھ: [0,1,0,3,12] آؤٹ پٹ ہونا چاہیے: [1,3,12,0,0] 2. ایک صف کے ساتھ: [0] آؤٹ پٹ ہونا چاہیے: [0] رک کر میرا فیصلہ لکھیں... میرا فیصلہ:

public static void moveZeroes(int[] nums) {
 int counterWithoutNulls = 0;
 int counterWithNulls = 0;
 int length = nums.length;
 while (counterWithNulls < length) {
   if (nums[counterWithNulls] == 0) {// находим нулевые элементы и увеличиваем счётчик
     counterWithNulls++;
   } else { // сдвигаем элементы на количество найденных нулевых элементов слева
     nums[counterWithoutNulls++] = nums[counterWithNulls++];
   }
 }
 while (counterWithoutNulls < length) {
   nums[counterWithoutNulls++] = 0;// заполняем последние элементы массива нулями согласно счётчику нулей
 }
}

امتحان:

int[] arr1 = {1, 2, 0, 0, 12, 9};
moveZeroes(arr1);
System.out.println(Arrays.toString(arr1));

int[] arr2 = {0};
moveZeroes(arr2);
System.out.println(Arrays.toString(arr2));

کنسول آؤٹ پٹ:

116. دی گئی فہرست <String> نام۔ ہر نام سے پہلا حرف ہٹائیں اور ترتیب شدہ فہرست کو گھمائیں۔

1. پہلی چیز جو ذہن میں آتی ہے وہ ہے Collections کلاس کے طریقے ، جس میں جمع کرنے کے بہت سے معاون طریقے شامل ہیں:

public static List<String> processTheList(List<String> nameList) {
 for (int i = 0; i < nameList.size(); i++) {
   nameList.set(i, nameList.get(i).substring(1));
 }
 Collections.sort(nameList);
 return nameList;
}

2. اس کے علاوہ، اگر ہم جاوا ورژن 8 اور اس سے زیادہ استعمال کرتے ہیں، تو ہمیں صرف اسٹریمز کے ذریعے حل دکھانا ہوگا:

public static List<String> processTheList(List<String> nameList) {
 return nameList.stream()
     .map(x -> x.substring(1))
     .sorted().collect(Collectors.toList());
}

منتخب کردہ حل سے قطع نظر، چیک مندرجہ ذیل ہو سکتا ہے:

List<String> nameList = new ArrayList();
nameList.add("John");
nameList.add("Bob");
nameList.add("Anna");
nameList.add("Dmitriy");
nameList.add("Peter");
nameList.add("David");
nameList.add("Igor");

System.out.println(processTheList(nameList));

کنسول آؤٹ پٹ:

117. صف کو پلٹائیں۔

حل 1 ایک بار پھر، پہلی چیز جو ذہن میں آتی ہے وہ ہے معاون یوٹیلیٹی کلاس کلیکشنز کے طریقوں کو استعمال کرنا ۔ لیکن چونکہ ہمارے پاس ایک صف ہے، ہمیں پہلے اسے ایک مجموعہ (فہرست) میں تبدیل کرنے کی ضرورت ہے:

public static Integer[] reverse(Integer[] arr) {
 List<Integer> list = Arrays.asList(arr);
 Collections.reverse(list);
 return list.toArray(arr);
}

حل 2 چونکہ سوال ایک صف کے بارے میں تھا، اس لیے میں سمجھتا ہوں کہ یہ ضروری ہے کہ حل کو خانہ سے باہر استعمال کیے بغیر، اور اسی طرح کلاسیکی کے مطابق:

public static Integer[] reverse(Integer[] arr) {
 for (int i = 0; i < arr.length / 2; i++) {
   int temp = arr[i];
   arr[i] = arr[arr.length - 1 - i];
   arr[arr.length - 1 - i] = temp;
 }
 return arr;
}

امتحان:

Integer[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.println(Arrays.toString(reverse(arr)));

کنسول آؤٹ پٹ:

118. چیک کریں کہ آیا تار ایک پیلینڈروم ہے۔

حل 1 StringBuilder کو فوری طور پر یاد رکھنے کے قابل ہے : یہ باقاعدہ String کے مقابلے میں زیادہ لچکدار اور مختلف طریقوں سے بھرپور ہے ۔ ہم خاص طور پر ریورس طریقہ میں دلچسپی رکھتے ہیں :

public static boolean isPalindrome(String string) {
 string = string.toLowerCase(); //приводит всю строку к нижнему регистру
 StringBuilder builder = new StringBuilder();
 builder.append(string);
 builder.reverse(); // перевочиваем строку методом Builder-а
 return (builder.toString()).equals(string);
}

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

public static boolean isPalindrome(String string) {
  string = string.toLowerCase();
 int length = string.length();
 int fromBeginning = 0;
 int fromEnd = length - 1;
 while (fromEnd > fromBeginning) {
   char forwardChar = string.charAt(fromBeginning++);
   char backwardChar = string.charAt(fromEnd--);
   if (forwardChar != backwardChar)
     return false;
 }
 return true;
}

اور ہم دونوں طریقوں کو چیک کرتے ہیں:

boolean isPalindrome = isPalindrome("Tenet");
System.out.println(isPalindrome);

کنسول آؤٹ پٹ:

119. ایک سادہ ترتیب دینے والا الگورتھم لکھیں (بلبلہ، انتخاب یا شٹل)۔ اسے کیسے بہتر کیا جا سکتا ہے؟

نفاذ کے لیے ایک سادہ الگورتھم کے طور پر، میں نے سلیکشن کی ترتیب کا انتخاب کیا - سلیکشن کی ترتیب:

public static void selectionSorting(int[] arr) {
 for (int i = 0; i < arr.length - 1; i++) {
   int min = i;
   for (int j = i + 1; j < arr.length; j++) {
     if (arr[j] < arr[min]) {
       min = j; // выбираем минимальный элемент в текущем числовом отрезке
     }
   }
   int temp = arr[min]; // меняем местами минимальный элемент с элементом под индексом i
   arr[min] = arr[i]; // так How отрезок постоянно уменьшается
   arr[i] = temp; // и выпадающие из него числа будут минимальными в текущем отрезке
 } // и How итог - числа оставшиеся вне текущей итерации отсортированы от самого наименьшего к большему
}

بہتر ورژن اس طرح نظر آئے گا:

public static void improvedSelectionSorting(int[] arr) {
 for (int i = 0, j = arr.length - 1; i < j; i++, j--) { // рассматриваемый отрезок с каждой итерацией
   // будет уменьшаться с ДВУХ сторон по одному элементу
   int min = arr[i];
   int max = arr[i];
   int minIndex = i;
   int maxIndex = i;
   for (int n = i; n <= j; n++) { // выбираем min и max на текущем отрезке
     if (arr[n] > max) {
       max = arr[n];
       maxIndex = n;
     } else if (arr[n] < min) {
       min = arr[n];
       minIndex = n;
     }
   }
   // меняем найденный минимальный элемент с позиции с индексом min на позицию с индексом i
   swap(arr, i, minIndex);

   if (arr[minIndex] == max) {// срабатывает, если элемент max оказался смещен предыдущей перестановкой -
     swap(arr, j, minIndex); // на старое место min, поэтому с позиции с индексом min смещаем его на позицию j
   } else {
     swap(arr, j, maxIndex); // простое обмен местами элементов с индексами max и j
   }
 }
}

static int[] swap(int[] arr, int i, int j) {
 int temp = arr[i];
 arr[i] = arr[j];
 arr[j] = temp;
 return arr;
}

ٹھیک ہے، اب ہمیں یہ یقینی بنانا ہوگا کہ آیا چھانٹنا واقعی بہتر ہوا ہے۔ آئیے کارکردگی کا موازنہ کریں:

long firstDifference = 0;
long secondDifference = 0;
long primaryTime;
int countOfApplying = 10000;
for (int i = 0; i < countOfApplying; i++) {
 int[] arr1 = {234, 33, 123, 4, 5342, 76, 3, 65,
     3, 5, 35, 75, 255, 4, 46, 48, 4658, 44, 22,
     678, 324, 66, 151, 268, 433, 76, 372, 45, 13,
     9484, 499959, 567, 774, 473, 3, 32, 865, 67, 43,
     63, 332, 24, 1};
 primaryTime = System.nanoTime();
 selectionSorting(arr1);
 firstDifference += System.nanoTime() - primaryTime;

 int[] arr2 = {234, 33, 123, 4, 5342, 76, 3, 65,
     3, 5, 35, 75, 255, 4, 46, 48, 4658, 44, 22,
     678, 324, 66, 151, 268, 433, 76, 372, 45, 13,
     9484, 499959, 567, 774, 473, 3, 32, 865, 67, 43,
     63, 332, 24, 1};
 primaryTime = System.nanoTime();
 improvedSelectionSorting(arr2);
 secondDifference += System.nanoTime() - primaryTime;
}

System.out.println(((double) firstDifference / (double) secondDifference - 1) * 100 + "%");

دونوں قسمیں ایک ہی چکر میں شروع ہوئیں، کیونکہ اگر الگ الگ لوپ ہوتے تو اوپر والے کوڈ میں چھانٹنا اس سے بدتر نتائج دکھائے گا اگر اسے دوسرے نمبر پر رکھا گیا ہو۔ یہ اس حقیقت کی وجہ سے ہے کہ پروگرام "گرم ہوجاتا ہے" اور پھر تھوڑا تیز کام کرتا ہے۔ لیکن میں موضوع سے تھوڑا ہٹ جاتا ہوں۔ کنسول میں اس چیک کے پانچ رنز کے بعد، میں نے کارکردگی میں اس طرح اضافہ دیکھا: 36.41006735635892% 51.46131097160771% 41.88918834013988% 48.091980705743566%2041474741474735666%2047420474147147147134013988 . بہت اچھا نتیجہ.

120. ٹائپ بائٹ کے لٹریل کے ساتھ ٹائپ انٹ کا لٹریل کمپوز کرنے کے لیے الگورتھم (اعمال کی ترتیب) لکھیں۔ یادداشت کا کیا ہوتا ہے اس کی وضاحت کریں۔

1. بائٹ ویلیو کو int میں تبدیل کیا جاتا ہے۔ اس کے لیے میموری کا 1 بائٹ مختص نہیں کیا جائے گا، لیکن تمام int ویلیوز کی طرح - 4، اگر یہ قدر ابھی int اسٹیک پر نہیں ہے۔ اگر وہاں ہے، تو اس کا لنک آسانی سے موصول ہو جائے گا۔

2. دو int ویلیوز کا اضافہ کیا جائے گا اور تیسری حاصل کی جائے گی۔ اس کے لیے ایک نیا میموری سیکشن مختص کیا جائے گا - 4 بائٹس (یا int اسٹیک سے موجودہ ویلیو کا حوالہ موصول ہوگا)۔

   اس صورت میں، دو انٹس کی یادداشت پر اب بھی قبضہ کیا جائے گا، اور ان کی قدریں بالترتیب int اسٹیک پر محفوظ کی جائیں گی۔

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