Upload 13 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+OrigVideo/Week3_Lecture4.mp4 filter=lfs diff=lfs merge=lfs -text

OrigVideo/Week3_Lecture4.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c459397e7d3d1d58b69d7649b7254e73ecc9d4ff0f967e3eeaff5a458732568a
+size 34824798

README.md

@@ -1,3 +1,101 @@
----
-license: cc-by-4.0
----
+# Lip-Sync Video Generation
+
+This project generates a lip-synced video based on an original video and translated subtitles.
+
+In general, after translating English text to Indian languages, the audio duration in Indian languages tends to be longer than that of the English version. This discrepancy creates a lag between the video and audio during synthesis. To address this issue and ensure synchronization, we initiated two projects:
+
+Project 1: generate_Lipsync_videos - In this project, we maintained the constant speed of the audio and slowed down the video by interpolating the video frames. This approach ensured proper synchronization between the audio and video, resulting in a video duration longer than the original.
+
+Project 2: [generate_lipsync_videos_with_length_match](https://github.com/smtiitm/generate_lipsync_videos_with_length_match/tree/main) -  This method aimed to maintain synchronization without altering the original video's duration by matching the utterance durations of the English version to the Indian language audio. However, this resulted in inconsistencies in audio speed, with some portions of the synthesized video playing very fast or slow, leading to poor output quality. To maintain audio quality and proper synchronization, we uniformly increased the audio speed based on the video duration requirement and placed it appropriately throughout the video.
+
+## Prerequisites
+
+- Conda
+- Python 3.8
+
+## Setup
+
+1. Clone the repository:
+
+    ```bash
+    git clone <repository-url>     #https://github.com/smtiitm/generate_Lipsync_videos.git
+    cd <repository-directory>     #generate_Lipsync_videos
+    ```
+
+2. Create and activate the conda environment:
+
+    ```bash
+    conda create -n lipsync_env python=3.8
+    conda activate lipsync_env
+    ```
+
+3. Install the required packages:
+
+    ```bash
+    pip install -r requirements.txt
+    ```
+4. Currently the code uses our APIs for text-to-speech generation. You can use your own TTS API (make sure to use the correct payload given in `vtt_to_speech.py` file) URL in `srt_to_audio_original` file. The current APIs are local to the lab and can be requested via mail.
+     
+## Usage
+
+1. Edit the `run_script.sh` file to assign the paths to your original video and translated subtitles:
+
+    ```bash
+    original_video_path="path/to/original_video.mp4"
+    translated_srt_path="path/to/translated_subtitles.srt"
+    ```
+
+2. Assign the target language code in `run_script.sh`:
+
+    ```bash
+    target_language_code="hin"  # Example: 'hin' for Hindi
+    ```
+
+3. Run the script:
+
+    ```bash
+    ./run_script.sh
+    ```
+4. Current supported sampling rate is 22.5KHz and .wav format is preferred.
+
+## Supported Languages
+
+- Hindi (hin)
+- Malayalam (mal)
+- Kannada (kan)
+- Bengali (bn)
+- Urdu (ur)
+- Telugu (tel)
+- Punjabi (pun)
+- Marathi (mar)
+- Gujarati (guj)
+- Tamil (tam)
+- English (en)
+
+### Citation
+If you use this repo in your research or work, please consider citing:
+
+“
+COPYRIGHT
+2024, Speech Technology Consortium,
+
+Bhashini, MeiTY and by Hema A Murthy & S Umesh,
+
+
+DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
+and
+ELECTRICAL ENGINEERING,
+IIT MADRAS. ALL RIGHTS RESERVED "
+
+
+
+Shield: [![CC BY 4.0][cc-by-shield]][cc-by]
+
+This work is licensed under a
+[Creative Commons Attribution 4.0 International License][cc-by].
+
+[![CC BY 4.0][cc-by-image]][cc-by]
+
+[cc-by]: http://creativecommons.org/licenses/by/4.0/
+[cc-by-image]: https://i.creativecommons.org/l/by/4.0/88x31.png
+[cc-by-shield]: https://img.shields.io/badge/License-CC%20BY%204.0-lightgrey.svg

TTS_AUDIO/VTT/Week4_Lecture3_Cleaned_Tagged.ta.vtt

@@ -0,0 +1,496 @@
+WEBVTT
+
+00:00:02.246 --> 00:00:06.190
+<DT>merge sort </DT> என்பது <DT>order</DT> <DNT>n log n</DNT> <DT>sorting algorithm</DT> என்று பார்த்தோம்.
+
+00:00:06.190 --> 00:00:10.509
+ஆனால் இது சில குறைபாடுகளைக் கொண்டுள்ளது. இது சில நேரங்களில் <DT>impractical</DT> ஆகிறது.
+
+00:00:10.849 --> 00:00:14.740
+முக்கிய பிரச்சனை என்னவென்றால், <DT>merging</DT> க்கு <DT>extra space</DT> தேவைப்படுகிறது.
+
+00:00:14.869 --> 00:00:19.076
+<DT>recursion</DT> ஐ பயன்படுத்தாமல் <DT>implement merge sort </DT> செய்வது கடினம் என்பதையும் நாம் பார்த்தோம்.
+
+00:00:19.101 --> 00:00:22.108
+மற்றும் <DT>recursion</DT> <DT>programming language</DT> ல் அதன் சொந்த செலவைக் கொண்டுள்ளது.
+
+00:00:24.841 --> 00:00:26.952
+எனவே, <DT>space problem</DT> ஐ தீர்க்கலாம்.
+
+00:00:27.736 --> 00:00:33.310
+<DT>merge function</DT> ஐ <DT>implement</DT> செய்யும் <DT>பொருட்டு</DT>, <DT>merge sort </DT> க்கு <DT>extra space</DT> தேவைப்படுகிறது.
+
+00:00:33.590 --> 00:00:38.500
+நாம் ஏன் <DT>merge</DT> செய்ய வேண்டும்?  நாம் <DT>merge</DT> செய்ய வேண்டியதன் காரணம், நாம் <DT>merge sort </DT> ஐ செய்யும்போது,
+
+00:00:38.500 --> 00:00:45.759
+நம்மிடம் <DT>initial list</DT> உள்ளது. பின்னர் அதை இரண்டு பகுதிகளாக split செய்கிறோம். ஆனால், பொதுவாக <DT>left</DT> இலிருந்து <DT>items</DT> கள் இருக்கலாம்.
+
+00:00:45.759 --> 00:00:50.409
+<DNT>right</DNT> இலிருந்து <DT>bigger than items</DT>. எனவே, <DT>instance</DT> ஆக நாம் சொன்னால்,
+
+00:00:50.450 --> 00:00:54.250
+<DT>left</DT> ல் <DT>even numbers</DT> மற்றும் <DNT>right</DNT> ல் <DT>odd numbers</DT>.
+
+00:00:54.550 --> 00:00:58.900
+இரண்டு பக்கங்களிலிருந்தும் <DT>numbers alternately</DT> எடுத்துக்கொண்டு <DT>merge</DT> செய்ய வேண்டும்.
+
+00:00:59.630 --> 00:01:09.646
+<DT>divided problem</DT> ன் <DT>left</DT> பக்கத்தில் உள்ள அனைத்தும் <DT>divided problem</DT> ன் <DNT>வலது</DNT> பக்கத்தில் உள்ள அனைத்தையும் விட சிறியதாக இருக்கும்படி <DT>arrange</DT> செய்தால்,
+
+00:01:10.593 --> 00:01:12.146
+பின்னர், நாம் அனைத்தையும் <DT>merge</DT> செய்ய தேவையில்லை.
+
+00:01:12.699 --> 00:01:18.130
+மேலும் இது <DT>merge</DT> செய்வதற்கு, கூடுதல் space தேவைப்படும் <DT>problem</DT> ஐ தவிர்க்கலாம்.
+
+00:01:20.689 --> 00:01:23.702
+<DT>merge</DT> இல்லாமல் எப்படி <DT>divide</DT> மற்றும் <DT>conquer</DT> செய்வது.
+
+00:01:25.243 --> 00:01:27.659
+<DT>median value</DT> நமக்குத் தெரியும் என்று வைத்துக்கொள்வோம்.
+
+00:01:27.659 --> 00:01:33.716
+ஒரு <DT>set</DT> ல் உள்ள <DT>median value</DT> என்பது <DT>half</DT> the <DT>elements</DT> are <DT>smaller than half</DT> are <DT>bigger</DT> ஆக இருக்கும் <DT>value</DT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+00:01:35.649 --> 00:01:42.124
+<DT>median</DT> விட <DT>smaller than</DT> <DT>values</DT> அனைத்தையும் <DT>left half</DT> க்கும், <DT>median</DT> விட <DT>bigger than</DT> அனைத்தையும் <DNT>right half</DNT> க்கும் நகர்த்தலாம்.
+
+00:01:43.883 --> 00:01:52.180
+நாம் பார்ப்பது போல, <DT>list</DT> ன் <DT>length</DT> க்கு <DT>time proportional</DT> ஆக புதிய <DT>array</DT> வை உருவாக்காமல் இதைச் செய்யலாம்.
+
+00:01:53.816 --> 00:02:00.989
+இந்த <DT>rearrangement</DT> ஐ செய்த பிறகு, அனைத்து <DT>smaller values</DT> களையும் <DT>left half</DT> க்கும் <DT>bigger values</DT> களை <DNT>right half</DNT> க்கும் நகர்த்தவும்.
+
+00:02:00.989 --> 00:02:06.443
+இந்த <DT>divide</DT> மற்றும் <DT>conquer strategy</DT> ஐ நாம் <DT>recursively</DT> பயன்படுத்தலாம். மேலும் <DNT>right</DNT> மற்றும் <DT>left half</DT> ஐ தனித்தனியாக <DT>sort</DT> செய்யலாம்.
+
+00:02:07.519 --> 00:02:12.520
+மேலும் <DT>left half</DT> ல் உள்ள அனைத்தும், <DNT>right half</DNT> ல் உள்ள அனைத்தையும் விட <DT>சிறியது</DT> என்று நாம் உத்தரவாதம் அளித்துள்ளோம்.
+
+00:02:13.019 --> 00:02:17.050
+இது தானாகவே இதற்கு அர்த்தம் <DT>divide</DT> மற்றும் <DT>conquer</DT> step க்கு பிறகு,
+
+00:02:17.050 --> 00:02:24.442
+<DT>left half</DT> ஏற்கனவே <DNT>right half</DNT> க்கு கீழே இருப்பதால், non-trivial முறையில் answers களை combine செய்ய வேண்டிய அவசியமில்லை. நாம் <DT>merge</DT> செய்ய தேவையில்லை.
+
+00:02:28.309 --> 00:02:34.210
+இந்த <DT>strategy</DT> ஐ பயன்படுத்தினால், <DT>merge sort </DT> போன்ற ஒரு <DT>recursive equation</DT> ஐ பெறுவோம்.
+
+00:02:34.210 --> 00:02:42.370
+<DNT>length n</DNT> இன் <DT>list</DT> ஐ <DT>sort</DT> செய்வதற்கு <DT>time</DT> தேவைப்படும். முதலில் <DNT>size n</DNT> இன் இரண்டு <DT>lists</DT> களை 2 ஆல் <DT>sort</DT> செய்ய வேண்டும்.
+
+00:02:42.370 --> 00:02:50.039
+நாம் <DNT>order n </DNT> ஐ செய்வோம் <DT>merging</DT> ஆக அல்ல.  <DT>list</DT> ஐ <DT>decompose</DT> செய்வதற்காக. அதனால் அனைத்து <DT>smaller values</DT> களும் <DT>left</DT> மற்றும் <DNT>right</DNT> இல் இருக்கும்.
+
+00:02:50.064 --> 00:02:54.483
+நாம் <DT>recursive step</DT> செய்வதற்கு முன் rearranging <DT>step</DT> <DNT>order n</DNT> ஆகும்.
+
+00:02:54.508 --> 00:02:57.879
+அதேசமயம் <DT>merge</DT> என்பது <DT>recursive step</DT> க்கு பின் வரும் <DT>step</DT> ஆகும்.
+
+00:02:57.879 --> 00:03:03.879
+இது முந்தைய <DT>case</DT> ல் <DNT>order n</DNT> ஆக இருந்தது. ஆனால் நாம் <DT>recurrence</DT> ஐ <DT>solve</DT>செய்தால் அதே ஒன்றுதான். நமக்கு மற்றொரு <DNT>order n log n algorithm</DNT> கிடைக்கும்.
+
+00:03:08.730 --> 00:03:12.340
+இந்த <DT>approach</DT> இல் பெரிய <DT>bottleneck</DT> என்னவென்றால் <DT>median</DT> ஐ கண்டறிவதாகும்.
+
+00:03:13.190 --> 00:03:20.663
+ஒரு <DT>list</DT> ஐ <DT>sorting</DT> செய்வதன் நன்மைகளில் ஒன்று, <DT>sorting</DT> க்கு பின் <DT>median</DT> ஐ  middle <DT>element</DT> ஆக நாம் அடையாளம் காணலாம் என்பதை நினைவில் கொள்ளுங்கள்.
+
+00:03:21.890 --> 00:03:24.336
+இப்போது, இங்கே நாம் <DT>sorting</DT> செய்வதற்கு முன் <DT>median</DT> ஐ கேட்கிறோம்.
+
+00:03:24.996 --> 00:03:28.539
+ஆனால், நமது நோக்கம் <DT>sort</DT> செய்வது. அது <DT>paradoxical</DT> ஆகும்.
+
+00:03:28.539 --> 00:03:33.219
+<DT>sorting</DT>ன் <DT>output</DT> <DT>sorting</DT> ஆன <DT>input</DT> ஆக இருக்க வேண்டும் என நாம் விரும்பினால்.
+
+00:03:34.892 --> 00:03:42.580
+எனவே, <DT>list</DT> ஐ <DNT>split</DNT> செய்து <DT>element</DT> ன் மிகவும் எளிமையான தேர்வு மூலம் <DT>strategy</DT> யை முயற்சிக்க வேண்டும் என்பதே இதன் பொருள்.
+
+00:03:42.825 --> 00:03:46.780
+<DT>median</DT> ஐ தேடுவதற்குப் பதிலாக, <DNT>list A</DNT> இல் சில <DT>value</DT> ஐ பெறுவோம்.
+
+00:03:46.780 --> 00:03:49.689
+மற்றும் <DT>pivot element</DT> என அழைக்கப்படுவதைப் பயன்படுத்தவும்.
+
+00:03:49.689 --> 00:03:56.769
+இந்த <DT>pivot</DT> ஐ பொறுத்து <DNT>A</DNT> என்று பிரிக்கிறோம். இதனால் அனைத்து <DT>smaller elements</DT> களும் <DT>left</DT> ஆகவும், <DT>bigger elements</DT> கள் ��னைத்தும் <DNT>right</DNT> ஆகவும் இருக்கும்.
+
+00:04:00.223 --> 00:04:11.636
+இந்த <DT>algorithm</DT> <DT>quick sort</DT> என்று அழைக்கப்படுகிறது. இது 1960 களில் <DT>Tony Four</DT> என்ற நபரால் கண்டுபிடிக்கப்பட்டது மற்றும் இது மிகவும் பிரபலமான <DT>sorting algorithms</DT> களில் ஒன்றாகும்.
+
+00:04:12.103 --> 00:04:16.082
+பொதுவாக <DT>array</DT> இன் <DT>list</DT> ல் முதல் <DT>element</DT> ஆக இருக்கும் <DT>pivot element</DT> ஐ தேர்வு செய்கிறோம்.
+
+00:04:16.759 --> 00:04:22.500
+இந்த <DT>pivot</DT> இன் முடிவைப் பொறுத்து <DT>lower part</DT> லும் <DT>upper part</DT> லும் <DNT>partition A</DNT> செய்கிறோம்.
+
+00:04:22.500 --> 00:04:24.943
+எனவே, அனைத்து <DT>smaller elements</DT> களையும் <DT>left</DT> க்கு நகர்த்துகிறோம்.
+
+00:04:25.056 --> 00:04:28.149
+மற்றும் அனைத்து <DT> bigger elements</DT> முதல் <DNT>right</DNT> வரை <DT>pivotal</DT> தேர்வைப் பொறுத்து.
+
+00:04:29.523 --> 00:04:34.163
+இரண்டிற்கும் இடையே <DT>pivot</DT> வருவதை உறுதிசெய்கிறோம். ஏனெனில் <DT>array</DT> ல் முதல் <DT>element</DT> <DT>pivot</DT> ஆக எடுத்துள்ளோம்.
+
+00:04:34.190 --> 00:04:41.036
+இதற்குப் பிறகு நாம் அதை <DT>lower</DT> மற்றும் <DT>upper bound</DT> க்கு இடையில் உள்ள <DT>center</DT> க்கு நகர்த்த விரும்புகிறோம். பின்னர், இரண்டு <DT>partitions</DT> களை <DT>recursively sort</DT> செய்கிறோம்.
+
+00:04:44.456 --> 00:04:48.910
+ஒரு பொதுவான <DT>list</DT> ல் <DT>quick sort</DT> எவ்வாறு வேலை செய்யும் என்பது பற்றிய <DT>high level view</DT> இங்கே உள்ளது.
+
+00:04:48.910 --> 00:04:56.143
+இது தான் நமது  <DT>list</DT> என்று வைத்துக்கொள்வோம். <DT>list</DT> ன் தொடக்கத்தை <DT>pivot element</DT> ஆக முதல் <DT>element</DT> ஐ அடையாளம் காண்போம்.
+
+00:04:56.950 --> 00:05:01.569
+இப்போது, மீதமுள்ள <DT>elements</DT> களில், எந்த <DNT>ones</DNT> <DT>smaller</DT> மற்றும் எந்த <DNT>ones</DNT> <DT>bigger</DT> என்பதைக் கண்டுபிடிக்க வேண்டும்.
+
+00:05:02.410 --> 00:05:11.510
+இதை எப்படிச் செய்வோம் என்று சொல்லாமல், 32, 22 மற்றும் 13 ஆகிய மூன்று <DT>elements</DT> களை <DT>smaller</DT> ஆகவும் <DNT>yellow</DNT> ல் <DT>marked </DT> செய்யபட்டதாகவும் அடையாளப்படுத்துகிறோம்.
+
+00:05:11.810 --> 00:05:15.069
+மற்றும் <DNT>green</DNT> இல் <DT>marked </DT> செய்யப்பட்ட மற்ற 4 <DT>elements</DT> கள் பெரியவை.
+
+00:05:16.160 --> 00:05:20.040
+முதல் <DT>step</DT> உண்மையில் இந்த <DT>criterion</DT> ஐ பொறுத்து <DT>partition</DT> செய்ய வேண்டும்.
+
+00:05:20.040 --> 00:05:24.810
+நாம் இந்த <DT>elements</DT> களை நகர்த்த வேண்டும். அதனால் அவை இரண்டு <DT>blocks</DT> ஆக வரும்.
+
+00:05:24.810 --> 00:05:27.550
+அந்த 13, 32 மற்றும் 22 <DT>left</DT> பக்கம் வரும்.
+
+00:05:27.550 --> 00:05:33.430
+63 57, 91 மற்றும் 78, <DNT>right</DNT> மற்றும் <DT>pivot element</DT> 43 <DT>middle</DT> ல் வருகிறது.
+
+00:05:33.947 --> 00:05:36.781
+இது <DT>rearranging step</DT> மற்றும் இப்போது
+
+00:05:37.060 --> 00:05:41.529
+நாம் <DNT>yellow bits</DNT> மற்றும் <DNT>green bits</DNT> ஆகியவற்றை <DT>recursively sort</DT> செய்வோம். பிறகு அதைச் செய்யலாம் என்று கருதினால்,
+
+00:05:41.529 --> 00:05:45.480
+நம்மிடம் ஒரு <DT>sorted array</DT> உள்ளது மற்றும் அனைத்து <DNT>yellow</DNT> பொருட்களும் <DT>smaller than </DT>43 ஆக இருப்ப��ை கவனிக்கவும்.
+
+00:05:45.480 --> 00:05:49.509
+மேலும் அனைத்து <DNT>green</DNT> விஷயங்களும் <DT>bigger than</DT> 43. மேலும் <DT>merging</DT> செய்ய தேவையில்லை.
+
+00:05:52.243 --> 00:05:54.899
+எனவே, <DT>partitioning</DT> எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்.
+
+00:05:54.899 --> 00:05:59.350
+இங்கே நம்மிடம் முந்தைய <DT>list</DT> ல் உள்ளது. மேலும் 43 ஐ நமது <DT>pivot element</DT> ஆக <DT>marked </DT> செய்துள்ளோம்.
+
+00:05:59.350 --> 00:06:03.112
+மீதமுள்ள <DT>elements</DT> களை <DT>scan</DT> செய்து அவற்றை <DT>divide</DT> செய்ய விரும்புகிறோம்.
+
+00:06:03.137 --> 00:06:08.742
+இரண்டு குழுக்கள், <DT>smaller than</DT> 43, <DNT>yellow ones</DNT>, <DT>bigger than</DT> 43, <DNT>green ones</DNT> மற்றும் அவற்றை <DT>rearrange</DT> செய்யவும்.
+
+00:06:09.962 --> 00:06:13.839
+நாம் என்ன செய்வோம் இரண்டு <DT>pointers</DT> கள் <DNT>yellow pointer</DNT> மற்றும் <DNT>green pointer</DNT> ஐ வைத்திருப்போம்.
+
+00:06:14.155 --> 00:06:19.081
+மேலும் பொதுவான விதி என்னவென்றால், எந்த ஒரு <DT>point</DT>லும் நாம் சிறிது <DT>distance</DT> ல் இருப்போம்.
+
+00:06:19.355 --> 00:06:24.129
+நான் <DNT>orange</DNT> நிறத்தில் வரையப் போகும் <DT>visible</DT> <DNT>yellow pointer</DNT> மற்றும் <DNT>green pointer</DNT>.
+
+00:06:24.129 --> 00:06:29.165
+இவை இந்த <DT>order</DT> ல் நகரும் <DNT>orange pointer</DNT> அல்லது <DNT>yellow pointer</DNT> எப்போதும் <DNT>green pointer</DNT> பின்னால் இருக்கும்.
+
+00:06:29.565 --> 00:06:35.397
+நீங்கள் பராமரிக்கும் <DT>inductive property</DT> என்னவென்றால், இந்த <DT>elements</DT> கள் 43 ஐ விட <DT>smaller than</DT> அல்லது சமமாகவோ இருக்கும்.
+
+00:06:35.910 --> 00:06:40.643
+இந்த <DT>elements</DT> கள் <DT>bigger than</DT> 43 மற்றும் இந்த <DT>elements</DT> கள் <DT>தெரியவில்லை</DT>.
+
+00:06:42.577 --> 00:06:46.139
+நாம் செய்ய முயற்சிப்பது என்னவென்றால், <DT>left</DT> ல் இருந்து <DNT>right</DNT> க்கு நகர்த்த முயற்சிக்கிறோம்.
+
+00:06:46.139 --> 00:06:49.589
+ஒவ்வொரு முறையும் <DT>unknown elements</DT> ஐ காணும் அனைத்து <DT>unknown elements</DT> களையும் <DT>classify</DT> செய்யவும்.
+
+00:06:49.552 --> 00:06:52.660
+இந்த property ஐ நாம் maintain பண்ண இரண்டு <DT>pointers</DT> களை மாற்றுவோம்.
+
+00:06:52.700 --> 00:06:57.699
+43 க்கும் முதல் <DT>pointer</DT> க்கும் இடையில் <DT>elements smaller than</DT> 43 அல்லது அதற்கு சமமாக உள்ளன.
+
+00:06:57.699 --> 00:07:01.494
+முதல் <DT>pointer</DT> க்கும் இரண்டாவது <DT>pointer</DT> க்கும் இடையில் நம் <DT>elements</DT> கள் கண்டிப்பாக 43 க்கு <DT>greater</DT> ஆக உள்ளது.
+
+00:07:01.752 --> 00:07:05.230
+மற்றும் <DNT>green pointer</DNT> இன் <DNT>right</DNT> பக்கம் இன்னும் <DT>scanned</DT> செய்யப்படாதவை  உள்ளன.
+
+00:07:07.023 --> 00:07:10.000
+எனவே, ஆரம்பத்தில் எதுவும் தெரியவில்லை. பின்னர் நாம் 32 ஐ பார்க்கிறோம்.
+
+00:07:10.000 --> 00:07:14.618
+32 43 ஐ விட <DT>smaller than</DT> ஆக இருப்பதால், <DNT>yellow pointer</DNT> ஐ நகர்த்துகிறோம். மேலும் <DNT>green pointer</DNT> ஐ உடன் தள்ளுகிறோம்.
+
+00:07:14.643 --> 00:07:16.949
+தெரியாத விஷயம் 22 இல் தொடங்குகிறது.
+
+00:07:16.949 --> 00:07:22.060
+<DNT>yellow</DNT> மற்றும் <DNT>green pointer</DNT> ஆகியவற்றுக்கு இடையே எதுவும் இல்லை. <DT>value bigger than</DT> 43 ஐ நாம் இன்னும் கண்டுபிடி��்கவில்லை.
+
+00:07:22.949 --> 00:07:24.910
+எனவே, 22 க்கும் அதே நடக்கும்.
+
+00:07:24.910 --> 00:07:28.629
+இப்போது, 78ஐ பார்க்கும்போது, 78 <DT>bigger than</DT> 43 என்பதைக் கவனிக்கிறோம்.
+
+00:07:29.008 --> 00:07:33.635
+இப்போது, நாம் <DNT>green pointer</DNT> ஐ மட்டுமே நகர்த்துகிறோம். மேலும் <DNT>yellow pointer</DNT> ஐ அல்ல. இப்போது, இந்த 3 இடைவெளிகளை முன்பு போலவே வைத்திருக்கிறோம்.
+
+00:07:33.935 --> 00:07:36.819
+இது 43 க்கு குறைவான <DT>equal</DT> ஆன பகுதி என்பதை நினைவில் கொள்ளுங்கள்.
+
+00:07:36.819 --> 00:07:44.350
+இது <DT>greater than</DT> 43 உள்ள பகுதி மற்றும் இந்த பகுதி unknown <DNT>right</DNT>, நாம் இந்த வழியில் தொடர்கிறோம்.
+
+00:07:44.350 --> 00:07:48.189
+இப்போது நாம் 63 ஐ பார்க்கிறோம். மீண்டும் 63 <DNT>green zone</DNT> ஐ நீட்டிக்கிறது.
+
+00:07:48.189 --> 00:07:52.540
+57 ஒரு <DNT>green zone</DNT> ஐ நீட்டிக்கிறது 91 ஒரு <DNT>green zone</DNT> ஐ நீட்டிக்கிறது.
+
+00:07:52.540 --> 00:07:56.470
+இப்போது, 13 ஐ கண்டுபிடிக்கும்போது நாம் ஏதாவது செய்ய வேண்டும்.
+
+00:07:56.470 --> 00:08:00.100
+13 என்பது இப்போது <DNT>yellow zone</DNT> ல் சேர்க்கப்பட வேண்டிய ஒரு <DT>element</DT>.
+
+00:08:00.205 --> 00:08:03.705
+ஒரு <DT>strategy</DT> நிறைய மாற்றங்களைச் செய்ய வேண்டும்.
+
+00:08:03.730 --> 00:08:07.360
+நாம் 13 ஐ 22 இருக்கும் இடத்திற்கு அல்லது 22 க்குப் பிறகு நகர்த்துகிறோம்.
+
+00:08:07.360 --> 00:08:10.180
+மேலும் 78 இல் இருந்து எல்லாவற்றையும் <DNT>right</DNT> க்கு தள்ளுகிறோம்.
+
+00:08:10.250 --> 00:08:15.220
+ஆனால் உண்மையில், ஒரு புத்திசாலித்தனமான <DT>strategy</DT> என்னவென்றால், 13 இங்கே செல்ல வேண்டும் என்று சொல்வது.
+
+00:08:17.605 --> 00:08:21.519
+நாம் space ஐ உருவாக்க வேண்டும். ஆனால் <DT>space</DT> ஐ உருவாக்குவதற்கு பதிலாக.
+
+00:08:21.519 --> 00:08:30.399
+எப்படியும் <DNT>green</DNT> விஷயங்களை நாம் <DT>sort</DT> செய்யபோகிறோம். அது  ஒரு பொருட்டல்ல என்று சொல்லலாம். இரண்டையும் எந்த வழியில் <DT>sort</DT> செய்கிறோம் என்பது எப்படி முக்கியம்.  இந்த 78ஐ எடுத்து 13க்கு நகர்த்துவோம்.
+
+00:08:30.399 --> 00:08:33.009
+எந்த மாற்றத்தையும் செய்வதற்கு பதிலாக.
+
+00:08:33.009 --> 00:08:36.370
+<DNT>green</DNT> zone ல் முதல் <DT>element</DT> ஐ <DT>exchange</DT> செய்கிறோம்.
+
+00:08:36.370 --> 00:08:38.320
+நாம் இதுவரை பார்க்கும் <DT>element</DT> உடன்.
+
+00:08:38.320 --> 00:08:41.980
+அது தானாகவே <DNT>yellow zone</DNT> மற்றும் <DNT>green zone</DNT> இரண்டையும் சரியாக நீட்டிக்கும்.
+
+00:08:42.080 --> 00:08:49.299
+நமது அடுத்த <DT>step</DT> 13 <DT>smaller than</DT> 43 என்பதை கண்டறிந்து, அதை 73 உடன் <DT>இடமாற்று</DT> செய்வது.
+
+00:08:49.399 --> 00:08:54.070
+இப்போது, நம்மிடம் உள்ள <DT>pivot</DT> ன் <DNT>right</DNT> க்கு ஒரு <DT>intermediate stage</DT> ஐ அடைந்துள்ளோம்.
+
+00:08:54.070 --> 00:08:58.360
+எல்லாவற்றையும் scanned செய்து, அவற்றை <DT>smaller</DT> ஆக வகைப்படுத்தியுள்ளோம்.
+
+00:08:58.360 --> 00:08:59.889
+மற்றும் <DT>bigger</DT> ஐயும்.
+
+00:09:00.716 --> 00:09:04.216
+இப்போது, <DNT>yellow</DNT> விஷயங்களை 43க்கு <DT>left</DT> பக்கம் <DT>push</DT> செய்ய வேண்டும்.
+
+00:09:05.036 --> 00:09:09.165
+இப்போது, <DNT>yellow zone</DNT> ல் 13ஐ சேர்த்தபோது பார்த்த அதே <DT>problem</DT> மீண்டும் ஒருமுறை நமக்கு வந்துள்ளது.
+
+00:09:09.190 --> 00:09:13.210
+நாம் 43 ஐ சரியான இடத்திற்கு நகர்த்தினால், இங்கே அனைத்தையும் <DNT>left</DNT> க்கு நகர்த்த வேண்டும்.
+
+00:09:13.404 --> 00:09:18.940
+ஆனால், அதற்குப் பதிலாக இந்த 13ஐ <DNT>yellow zone</DNT> ல் கடைசி <DT>element</DT> ஆக எடுத்துக்கொள்ளலாம்.
+
+00:09:18.940 --> 00:09:22.149
+மற்றும் அதை அங்கே <DT>replace</DT> செய்யவும். 32 மற்றும் 22 ஐ shift செய்ய வேண்டாம்.
+
+00:09:22.149 --> 00:09:26.759
+இது <DT>order</DT> ஐ சீர்குலைக்கிறது. ஆனால் எப்படியும் இது <DT>unsorted</DT> செய்யாமல், <DT>unsorted</DT> ஆக உள்ளது.
+
+00:09:27.632 --> 00:09:29.889
+நாம் இதை செய்கிறோம். இப்போது நம்மிடம் உள்ளது.
+
+00:09:30.001 --> 00:09:36.171
+நாம் விரும்பியபடி <DT>array rearranged</DT> செய்யப்பட்டது.  எனவே, <DT>left</DT> ல் உள்ள இவை அனைத்தும் <DT>smaller than</DT> <DT>pivot</DT>.
+
+00:09:37.244 --> 00:09:41.856
+<DT>pivot</DT> நடுவில் உள்ளது.  மற்றும் <DNT>right</DNT> ல் உள்ள அனைத்தும் <DT>bigger than</DT> <DT>pivot</DT>.
+
+00:09:46.550 --> 00:09:53.830
+இங்கே <DT>python</DT> இன் ஒரு <DT>implementation</DT> உள்ளது. <DT>quick sort</DT> என்பது  <DT>merge sort </DT> மற்றும் <DT>binary research</DT> போன்றவற்றைக் கொண்டிருக்கும் என்பதை நினைவில் கொள்ளவும்.
+
+00:09:53.830 --> 00:09:58.690
+<DT>smaller</DT> மற்றும் <DT>smaller segments</DT> ல் அதை மீண்டும் மீண்டும் பயன்படுத்துகிறோம். பொதுவாக நாம் அதை <DT>pass</DT> செய்யவும்.
+
+00:09:58.690 --> 00:10:03.523
+நாம் <DNT>call A</DNT> என்ற <DT>list</DT> க்கும், <DT>segment</DT> ன் <DT>end points</DT> ஆன <DNT>left</DNT> மற்றும் <DNT>right</DNT>.
+
+00:10:03.548 --> 00:10:07.238
+நாம் ஒரு <DNT>slice l </DNT> முதல் <DNT>r minus 1</DNT> வரை செய்கிறோம்.
+
+00:10:08.244 --> 00:10:13.210
+இந்த <DT>slice</DT> 1 அல்லது 0 <DT>length</DT> ஆக இருந்தால், நாம் எதுவும் செய்ய மாட்டோம்.
+
+00:10:14.223 --> 00:10:17.320
+இல்லையெனில், நாம் முன்பு இருந்த இந்த <DT>partitioning strategy</DT> ஐ பின்பற்றுவோம்.
+
+00:10:17.708 --> 00:10:22.120
+அதாவது <DNT>l</DNT> இலிருந்து <DNT>r minus 1</DNT> வரை <DT>sorting</DT> செய்கிறோம்.
+
+00:10:22.120 --> 00:10:24.220
+எனவே, <DT>position l</DT>.
+
+00:10:24.379 --> 00:10:25.899
+இது <DT>pivot</DT> ஆகும்.
+
+00:10:26.793 --> 00:10:29.671
+<DNT>right</DNT> முதலில் இங்கே <DNT>yellow pointer</DNT> ஐ வைப்போம்.
+
+00:10:31.011 --> 00:10:33.635
+<DNT>yellow zone</DNT> இன் முடிவு என்று கூறுகிறது.
+
+00:10:34.005 --> 00:10:38.500
+உண்மையில் <DT>pivot</DT> உள்ளது அங்கு எதுவும் இல்லை. <DNT>yellow</DNT> என்பது <DNT>l plus 1</DNT> ஆகும்.
+
+00:10:38.500 --> 00:10:50.781
+இப்போது <DNT>green</DNT>ஐ தொடர அனுமதிக்கிறோம். ஒவ்வொரு <DT>time</DT>ம் <DNT>green</DNT> இல் ஒரு <DT>element</DT> ஐ பார்க்கும்போது புதிய <DNT>green</DNT> ஒன்றைக் காட்டிலும் <DT>smaller than</DT> ஆக இருக்கும் <DT>pivot</DT> ஆகும். இது <DT>pivot</DT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+00:10:51.965 --> 00:10:55.661
+<DNT>right</DNT> நாம் எப்போதாவது ஒரு <DNT>green</DNT> ஐ பார்த்தால், அடுத்த <DT>value</DT> ஐ.
+
+00:10:55.686 --> 00:10:57.580
+சரிபார்க்கப்பட வேண்டியதை விட <DT>smaller than</DT> அல்லது சமமானது.
+
+00:10:57.590 --> 00:11:01.714
+நாம் <DT>exchange</DT> செய்கிறோம். இதனால் இந்த <DT>value</DT> ஐ <DNT>yellow zone</DNT> ன் முடிவுக்குக் கொண்டு வருகிறோம்.
+
+00:11:01.739 --> 00:11:03.220
+இதைத்தான் 13ல் செய்தோம்.
+
+00:11:03.344 --> 00:11:07.590
+பின்னர், <DNT>yellow pointer</DNT> ஐ நகர்த்துகிறோம். இல்லையெனில் கண்டிப்பாக <DT>bigger</DT> <DT>value</DT> ஐ கண்டால் நகர்த்துவோம்.
+
+00:11:07.590 --> 00:11:11.860
+<DNT>green pointer</DNT> மட்டுமே <DT>for loop</DT> ஆல் மறைமுகமாக செய்யப்படுகிறது. மற்றொன்றை நகர்த்த மாட்டோம்.
+
+00:11:11.929 --> 00:11:14.883
+இதன் முடிவில் நமக்கு <DT>pivot</DT> உள்ளது.
+
+00:11:15.894 --> 00:11:19.784
+நாம் <DT>pivot</DT> க்கு சமமானதைக் காட்டிலும் குறைவானதைக் கொண்டுள்ளோம். பின்னர் <DT>greater than pivot</DT> ம் கொண்டுள்ளோம்.
+
+00:11:19.809 --> 00:11:27.914
+இந்த விதியின் முடிவில் நாம் அடைந்த அந்த intermediate stage இதுதான். இப்போது, நாம் <DT>pivot</DT> ஐ கண்டுபிடித்து சரியான இடத்திற்கு நகர்த்த வேண்டும். எனவே, <DNT>yellow</DNT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+00:11:29.241 --> 00:11:32.769
+<DNT>yellow</DNT> <DNT>last</DNT> க்கு அப்பால் உள்ள <DT>position</DT> ஐ சுட்டிக்காட்டுகிறது.
+
+00:11:32.769 --> 00:11:37.440
+<DT>element அதை விட சிறியது</DT>. <DNT>yellow</DNT> இதற்கு முன் எப்போதும் ஒரு <DT>value</DT> ஆகும்.
+
+00:11:37.440 --> 00:11:40.396
+<DNT>yellow</DNT> minus 1 இன் <DT>value</DT> ஐ எடுத்து, <DT>left value</DT> உடன் <DT>exchange</DT> செய்வோம்.
+
+00:11:41.414 --> 00:11:48.765
+இப்போது நாம் செய்ய வேண்டியது என்னவென்றால், நம்மிடம் இப்போது <DNT> p, p and greater than p</DNT> ஐ விட குறைவாக உள்ளது.
+
+00:11:49.627 --> 00:12:01.350
+இங்குதான் <DNT>yellow</DNT> <DNT>சரியானது</DNT>. நாம் 0 இலிருந்து <DNT>yellow</DNT> minus 1 க்கு செல்ல வேண்டும். மீண்டும் <DNT>sort p </DNT> ஐ விரும்பவில்லை. ஏனெனில் <DNT>p</DNT> ஏற்கனவே சரியான இடத்தில் வைக்கப்பட்டுள்ளது.
+
+00:12:01.350 --> 00:12:06.391
+<DNT>L</DNT> இலிருந்து <DNT>yellow</DNT> minus 1 ஆகவும், <DNT>yellow</DNT> இலிருந்து <DNT>right</DNT> முனையிலும் <DT>quick sort</DT> செய்வோம்.
+
+00:12:13.070 --> 00:12:17.070
+<DT>slide</DT> ல் பார்த்த <DT>python code</DT> ஐ இங்கே ஒரு <DT>file</DT> ல் எழுதியுள்ளோம்.
+
+00:12:17.070 --> 00:12:20.320
+slide ல் இருந்த அதே <DT>code</DT> இதுதானா என்பதை சரிபார்க்கலாம்.
+
+00:12:20.345 --> 00:12:28.786
+நாம் அதை முயற்சி செய்து <DT>run</DT> செய்யலாம் மற்றும் அது செயல்படுகிறதா என்று சரிபார்க்கலாம். <DT>call python</DT>, இந்த <DT>function</DT> ஐ <DT>import</DT> செய்கிறோம்.
+
+00:12:32.849 --> 00:12:37.699
+இது மீண்டும் ஒரு வகையான <DT>sorts</DT> <DT>function</DT> என்பதை நினைவில் கொள்ளுங்கள். எதையாவது <DT>sort</DT> செய்து அதன் விளைவைப் பார்க்க விரும்பினால்.
+
+00:12:37.753 --> 00:12:40.870
+நாம் அதற்கு ஒரு <DT>name</DT> ஐ <DT>assign</DT> செய்ய வேண்டும். பின்னர் அந்த <DT>name</DT> ஐ <DT>sort</DT> செய்து, பிறகு <DT>name</DT> ஐ சரிபார்க்க வேண்டும்.
+
+00:12:40.909 --> 00:12:48.137
+எடுத்துக்காட்டாக, 500 முதல் 0 வரைய���லான <DT>range</DT> of <DT>values</DT> ஐ எடுத்துக் கொள்வோம்.
+
+00:12:50.287 --> 00:12:58.090
+இப்போது நாம் <DNT>quicksort l</DNT> என்று சொன்னால், அதற்கு <DNT>of course</DNT> முடிவைக் கொடுக்க வேண்டும்.
+
+00:13:01.020 --> 00:13:02.468
+பிறகு <DNT>l</DNT> சரியாக <DT>sorted</DT> செய்யப்படும்.
+
+00:13:04.311 --> 00:13:09.523
+நீங்கள் அனைத்தையும் பார்க்க முடியாது. ஆனால்  83 84 முதல் நூறு வரை மற்றும் இரண்டு 500 வரை பார்க்க முடியும்.
+
+00:13:10.995 --> 00:13:16.480
+இப்போது, 1000 என்று சொன்னால், <DT>insertion sort</DT> ல் நமக்கு இருந்த அதே <DT>problem</DT> உள்ளது.
+
+00:13:17.897 --> 00:13:22.596
+பின்னர் நாம் இதை <DT>quicksort</DT> செய்ய முயற்சிக்கிறோம். நீங்கள் இதை <DT>recursion depth</DT> ஆல் பெறுவீர்கள்.
+
+00:13:22.621 --> 00:13:29.644
+<DT>worst case</DT> ல் நாம் பார்ப்பது போல, <DT>quick sort</DT> ஆனது <DT>insertion sort</DT> ஐ போலவே செயல்படுகிறது மற்றும் இது மோசமான case.
+
+00:13:29.669 --> 00:13:33.759
+இதைப் போக்க, நாம் வழக்கமான காரியத்தைச் செய்ய வேண்டும். <DT>SYS module</DT> ஐ <DT>import</DT> செய்ய வேண்டும்.
+
+00:13:33.759 --> 00:13:35.409
+<DT>recursion limit</DT> ஐ <DT>set</DT> செய்யவும்.
+
+00:13:36.658 --> 00:13:43.652
+எனவே, பொருத்தமான பெரிய ஒன்று பத்தாயிரம் அல்லது நூறாயிரம் என்று சொல்லுங்கள். பின்னர் அதை <DT>quicksort</DT> செய்ய சொன்னால் எந்த problem உம்  இல்லை.
+
+00:13:44.779 --> 00:13:49.299
+<DT>python</DT> ல் இந்த <DT>recursion limit</DT> ஐ manually set செய்ய வேண்டிய மற்றொரு case இதுவாகும்.
+
+00:13:49.647 --> 00:13:56.929
+உண்மையில் நாம் பார்க்கக்கூடிய ஒரு விஷயம் என்னவென்றால், <DT>quicksort</DT> என்பது நாம் நம்புவது போல் நல்லதல்ல, ஏனெனில்.
+
+00:13:57.008 --> 00:14:02.080
+எடுத்துக்காட்டாக, 7500 என்று ஏதாவது <DT>size</DT> ஐ <DT>instance sort</DT> செய்யவும்.
+
+00:14:05.504 --> 00:14:09.554
+பின்னர் அது ஒரு புலப்படும் நேரம் எடுக்கும். எனவே, <DNT>n log n</DNT> என்று <DT>merge sort </DT> ஐ பார்த்தோம்.
+
+00:14:09.790 --> 00:14:13.700
+5,000 மற்றும் 10000 மற்றும் 100,000 கூட <DT>instantaneously</DT> செய்யும்.
+
+00:14:13.832 --> 00:14:18.129
+தெளிவாக <DT>quick sort</DT> மற்றும் <DT>merge sort </DT> செயல்படாது.
+
+00:14:18.165 --> 00:14:22.480
+மற்றும் உண்மையில் <DT>quick sort</DT> க்கு <DT>order</DT> <DNT>n log n</DNT> <DT>merge sort </DT> இல்லை என்பதை நாம் பார்ப்போம்.
+
+00:14:22.511 --> 00:14:25.090
+நாம் விரும்பியபடி நடத்தை.
+
+00:14:25.090 --> 00:14:28.539
+அதற்குக் காரணம், நாம் <DT>median</DT> ஐ பயன்படுத்தாமல், split செய்வதற்கான முதல் <DT>value</DT> ஐ பயன்படுத்துகிறோம்.
+
+00:14:28.539 --> 00:14:33.909
+அதை அடுத்த lecture ல் பார்ப்போம்.  ஏன் <DT>quick sort</DT> ல் உண்மையில் ஒரு worst case <DNT>order n log n algorithm</DNT> அல்ல.

Translated_SRT/Week3_Lecture4_Cleaned_Tagged.ta.srt

@@ -0,0 +1,659 @@
+1
+00:00:02,246 --> 00:00:06,190
+<DT>merge sort </DT> என்பது <DT>order</DT> <DNT>n log n</DNT> <DT>sorting algorithm</DT> என்று பார்த்தோம்.
+
+2
+00:00:06,190 --> 00:00:10,509
+ஆனால் இது சில குறைபாடுகளைக் கொண்டுள்ளது. இது சில நேரங்களில் <DT>impractical</DT> ஆகிறது.
+
+3
+00:00:10,849 --> 00:00:14,740
+முக்கிய பிரச்சனை என்னவென்றால், <DT>merging</DT> க்கு <DT>extra space</DT> தேவைப்படுகிறது.
+
+4
+00:00:14,869 --> 00:00:19,076
+<DT>recursion</DT> ஐ பயன்படுத்தாமல் <DT>implement merge sort </DT> செய்வது கடினம் என்பதையும் நாம் பார்த்தோம்.
+
+5
+00:00:19,101 --> 00:00:22,108
+மற்றும் <DT>recursion</DT> <DT>programming language</DT> ல் அதன் சொந்த செலவைக் கொண்டுள்ளது.
+
+6
+00:00:24,841 --> 00:00:26,952
+எனவே, <DT>space problem</DT> ஐ தீர்க்கலாம்.
+
+7
+00:00:27,736 --> 00:00:33,310
+<DT>merge function</DT> ஐ <DT>implement</DT> செய்யும் <DT>பொருட்டு</DT>, <DT>merge sort </DT> க்கு <DT>extra space</DT> தேவைப்படுகிறது.
+
+8
+00:00:33,590 --> 00:00:38,500
+நாம் ஏன் <DT>merge</DT> செய்ய வேண்டும்?  நாம் <DT>merge</DT> செய்ய வேண்டியதன் காரணம், நாம் <DT>merge sort </DT> ஐ செய்யும்போது,
+
+9
+00:00:38,500 --> 00:00:45,759
+நம்மிடம் <DT>initial list</DT> உள்ளது. பின்னர் அதை இரண்டு பகுதிகளாக split செய்கிறோம். ஆனால், பொதுவாக <DT>left</DT> இலிருந்து <DT>items</DT> கள் இருக்கலாம்.
+
+10
+00:00:45,759 --> 00:00:50,409
+<DNT>right</DNT> இலிருந்து <DT>bigger than items</DT>. எனவே, <DT>instance</DT> ஆக நாம் சொன்னால்,
+
+11
+00:00:50,450 --> 00:00:54,250
+<DT>left</DT> ல் <DT>even numbers</DT> மற்றும் <DNT>right</DNT> ல் <DT>odd numbers</DT>.
+
+12
+00:00:54,550 --> 00:00:58,900
+இரண்டு பக்கங்களிலிருந்தும் <DT>numbers alternately</DT> எடுத்துக்கொண்டு <DT>merge</DT> செய்ய வேண்டும்.
+
+13
+00:00:59,630 --> 00:01:09,646
+<DT>divided problem</DT> ன் <DT>left</DT> பக்கத்தில் உள்ள அனைத்தும் <DT>divided problem</DT> ன் <DNT>வலது</DNT> பக்கத்தில் உள்ள அனைத்தையும் விட சிறியதாக இருக்கும்படி <DT>arrange</DT> செய்தால்,
+
+14
+00:01:10,593 --> 00:01:12,146
+பின்னர், நாம் அனைத்தையும் <DT>merge</DT> செய்ய தேவையில்லை.
+
+15
+00:01:12,699 --> 00:01:18,130
+மேலும் இது <DT>merge</DT> செய்வதற்கு, கூடுதல் space தேவைப்படும் <DT>problem</DT> ஐ தவிர்க்கலாம்.
+
+16
+00:01:20,689 --> 00:01:23,702
+<DT>merge</DT> இல்லாமல் எப்படி <DT>divide</DT> மற்றும் <DT>conquer</DT> செய்வது.
+
+17
+00:01:25,243 --> 00:01:27,659
+<DT>median value</DT> நமக்குத் தெரியும் என்று வைத்துக்கொள்வோம்.
+
+18
+00:01:27,659 --> 00:01:33,716
+ஒரு <DT>set</DT> ல் உள்ள <DT>median value</DT> என்பது <DT>half</DT> the <DT>elements</DT> are <DT>smaller than half</DT> are <DT>bigger</DT> ஆக இருக்கும் <DT>value</DT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+19
+00:01:35,649 --> 00:01:42,124
+<DT>median</DT> விட <DT>smaller than</DT> <DT>values</DT> அனைத்தையும் <DT>left half</DT> க்கும், <DT>median</DT> விட <DT>bigger than</DT> அனைத்தையும் <DNT>right half</DNT> க்கும் நகர்த்தலாம்.
+
+20
+00:01:43,883 --> 00:01:52,180
+நாம் பார்ப்பது போல, <DT>list</DT> ன் <DT>length</DT> க்கு <DT>time proportional</DT> ஆக புதிய <DT>array</DT> வை உருவாக்காமல் இதைச் செய்யலாம்.
+
+21
+00:01:53,816 --> 00:02:00,989
+இந்த <DT>rearrangement</DT> ஐ செய்த பிறகு, அனைத்து <DT>smaller values</DT> களையும் <DT>left half</DT> க்கும் <DT>bigger values</DT> களை <DNT>right half</DNT> க்கும் நகர்த்தவும்.
+
+22
+00:02:00,989 --> 00:02:06,443
+இந்த <DT>divide</DT> மற்றும் <DT>conquer strategy</DT> ஐ நாம் <DT>recursively</DT> பயன்படுத்தலாம். மேலும் <DNT>right</DNT> மற்றும் <DT>left half</DT> ஐ தனித்தனியாக <DT>sort</DT> செய்யலாம்.
+
+23
+00:02:07,519 --> 00:02:12,520
+மேலும் <DT>left half</DT> ல் உள்ள அனைத்தும், <DNT>right half</DNT> ல் உள்ள அனைத்தையும் விட <DT>சிறியது</DT> என்று நாம் உத்தரவாதம் அளித்துள்ளோம்.
+
+24
+00:02:13,019 --> 00:02:17,050
+இது தானாகவே இதற்கு அர்த்தம் <DT>divide</DT> மற்றும் <DT>conquer</DT> step க்கு பிறகு,
+
+25
+00:02:17,050 --> 00:02:24,442
+<DT>left half</DT> ஏற்கனவே <DNT>right half</DNT> க்கு கீழே இருப்பதால், non-trivial முறையில் answers களை combine செய்ய வேண்டிய அவசியமில்லை. நாம் <DT>merge</DT> செய்ய தேவையில்லை.
+
+26
+00:02:28,309 --> 00:02:34,210
+இந்த <DT>strategy</DT> ஐ பயன்படுத்தினால், <DT>merge sort </DT> போன்ற ஒரு <DT>recursive equation</DT> ஐ பெறுவோம்.
+
+27
+00:02:34,210 --> 00:02:42,370
+<DNT>length n</DNT> இன் <DT>list</DT> ஐ <DT>sort</DT> செய்வதற்கு <DT>time</DT> தேவைப்படும். முதலில் <DNT>size n</DNT> இன் இரண்டு <DT>lists</DT> களை 2 ஆல் <DT>sort</DT> செய்ய வேண்டும்.
+
+28
+00:02:42,370 --> 00:02:50,039
+நாம் <DNT>order n </DNT> ஐ செய்வோம் <DT>merging</DT> ஆக அல்ல.  <DT>list</DT> ஐ <DT>decompose</DT> செய்வதற்காக. அதனால் அனைத்து <DT>smaller values</DT> களும் <DT>left</DT> மற்றும் <DNT>right</DNT> இல் இருக்கும்.
+
+29
+00:02:50,064 --> 00:02:54,483
+நாம் <DT>recursive step</DT> செய்வதற்கு முன் rearranging <DT>step</DT> <DNT>order n</DNT> ஆகும்.
+
+30
+00:02:54,508 --> 00:02:57,879
+அதேசமயம் <DT>merge</DT> என்பது <DT>recursive step</DT> க்கு பின் வரும் <DT>step</DT> ஆகும்.
+
+31
+00:02:57,879 --> 00:03:03,879
+இது முந்தைய <DT>case</DT> ல் <DNT>order n</DNT> ஆக இருந்தது. ஆனால் நாம் <DT>recurrence</DT> ஐ <DT>solve</DT>செய்தால் அதே ஒன்றுதான். நமக்கு மற்றொரு <DNT>order n log n algorithm</DNT> கிடைக்கும்.
+
+32
+00:03:08,730 --> 00:03:12,340
+இந்த <DT>approach</DT> இல் பெரிய <DT>bottleneck</DT> என்னவென்றால் <DT>median</DT> ஐ கண்டறிவதாகும்.
+
+33
+00:03:13,190 --> 00:03:20,663
+ஒரு <DT>list</DT> ஐ <DT>sorting</DT> செய்வதன் நன்மைகளில் ஒன்று, <DT>sorting</DT> க்கு பின் <DT>median</DT> ஐ  middle <DT>element</DT> ஆக நாம் அடையாளம் காணலாம் என்பதை நினைவில் கொள்ளுங்கள்.
+
+34
+00:03:21,890 --> 00:03:24,336
+இப்போது, இங்கே நாம் <DT>sorting</DT> செய்வதற்கு முன் <DT>median</DT> ஐ கேட்கிறோம்.
+
+35
+00:03:24,996 --> 00:03:28,539
+ஆனால், நமது நோக்கம் <DT>sort</DT> செய்வது. அது <DT>paradoxical</DT> ஆகும்.
+
+36
+00:03:28,539 --> 00:03:33,219
+<DT>sorting</DT>ன் <DT>output</DT> <DT>sorting</DT> ஆன <DT>input</DT> ஆக இருக்க வேண்டும் என நாம் விரும்பினால்.
+
+37
+00:03:34,892 --> 00:03:42,580
+எனவே, <DT>list</DT> ஐ <DNT>split</DNT> செய்து <DT>element</DT> ன் மிகவும் எளிமையான தேர்வு மூலம் <DT>strategy</DT> யை முயற்சிக்க வேண்டும் என்பதே இதன் பொருள்.
+
+38
+00:03:42,825 --> 00:03:46,780
+<DT>median</DT> ஐ தேடுவதற்குப் பதிலாக, <DNT>list A</DNT> இல் சில <DT>value</DT> ஐ பெறுவோம்.
+
+39
+00:03:46,780 --> 00:03:49,689
+மற்றும் <DT>pivot element</DT> என அழைக்கப்படுவதைப் பயன்படுத்தவும்.
+
+40
+00:03:49,689 --> 00:03:56,769
+இந்த <DT>pivot</DT> ஐ பொறுத்து <DNT>A</DNT> என்று பிரிக்கிறோம். இதன���ல் அனைத்து <DT>smaller elements</DT> களும் <DT>left</DT> ஆகவும், <DT>bigger elements</DT> கள் அனைத்தும் <DNT>right</DNT> ஆகவும் இருக்கும்.
+
+41
+00:04:00,223 --> 00:04:11,636
+இந்த <DT>algorithm</DT> <DT>quick sort</DT> என்று அழைக்கப்படுகிறது. இது 1960 களில் <DT>Tony Four</DT> என்ற நபரால் கண்டுபிடிக்கப்பட்டது மற்றும் இது மிகவும் பிரபலமான <DT>sorting algorithms</DT> களில் ஒன்றாகும்.
+
+42
+00:04:12,103 --> 00:04:16,082
+பொதுவாக <DT>array</DT> இன் <DT>list</DT> ல் முதல் <DT>element</DT> ஆக இருக்கும் <DT>pivot element</DT> ஐ தேர்வு செய்கிறோம்.
+
+43
+00:04:16,759 --> 00:04:22,500
+இந்த <DT>pivot</DT> இன் முடிவைப் பொறுத்து <DT>lower part</DT> லும் <DT>upper part</DT> லும் <DNT>partition A</DNT> செய்கிறோம்.
+
+44
+00:04:22,500 --> 00:04:24,943
+எனவே, அனைத்து <DT>smaller elements</DT> களையும் <DT>left</DT> க்கு நகர்த்துகிறோம்.
+
+45
+00:04:25,056 --> 00:04:28,149
+மற்றும் அனைத்து <DT> bigger elements</DT> முதல் <DNT>right</DNT> வரை <DT>pivotal</DT> தேர்வைப் பொறுத்து.
+
+46
+00:04:29,523 --> 00:04:34,163
+இரண்டிற்கும் இடையே <DT>pivot</DT> வருவதை உறுதிசெய்கிறோம். ஏனெனில் <DT>array</DT> ல் முதல் <DT>element</DT> <DT>pivot</DT> ஆக எடுத்துள்ளோம்.
+
+47
+00:04:34,190 --> 00:04:41,036
+இதற்குப் பிறகு நாம் அதை <DT>lower</DT> மற்றும் <DT>upper bound</DT> க்கு இடையில் உள்ள <DT>center</DT> க்கு நகர்த்த விரும்புகிறோம். பின்னர், இரண்டு <DT>partitions</DT> களை <DT>recursively sort</DT> செய்கிறோம்.
+
+48
+00:04:44,456 --> 00:04:48,910
+ஒரு பொதுவான <DT>list</DT> ல் <DT>quick sort</DT> எவ்வாறு வேலை செய்யும் என்பது பற்றிய <DT>high level view</DT> இங்கே உள்ளது.
+
+49
+00:04:48,910 --> 00:04:56,143
+இது தான் நமது  <DT>list</DT> என்று வைத்துக்கொள்வோம். <DT>list</DT> ன் தொடக்கத்தை <DT>pivot element</DT> ஆக முதல் <DT>element</DT> ஐ அடையாளம் காண்போம்.
+
+50
+00:04:56,950 --> 00:05:01,569
+இப்போது, மீதமுள்ள <DT>elements</DT> களில், எந்த <DNT>ones</DNT> <DT>smaller</DT> மற்றும் எந்த <DNT>ones</DNT> <DT>bigger</DT> என்பதைக் கண்டுபிடிக்க வேண்டும்.
+
+51
+00:05:02,410 --> 00:05:11,510
+இதை எப்படிச் செய்வோம் என்று சொல்லாமல், 32, 22 மற்றும் 13 ஆகிய மூன்று <DT>elements</DT> களை <DT>smaller</DT> ஆகவும் <DNT>yellow</DNT> ல் <DT>marked </DT> செய்யபட்டதாகவும் அடையாளப்படுத்துகிறோம்.
+
+52
+00:05:11,810 --> 00:05:15,069
+மற்றும் <DNT>green</DNT> இல் <DT>marked </DT> செய்யப்பட்ட மற்ற 4 <DT>elements</DT> கள் பெரியவை.
+
+53
+00:05:16,160 --> 00:05:20,040
+முதல் <DT>step</DT> உண்மையில் இந்த <DT>criterion</DT> ஐ பொறுத்து <DT>partition</DT> செய்ய வேண்டும்.
+
+54
+00:05:20,040 --> 00:05:24,810
+நாம் இந்த <DT>elements</DT> களை நகர்த்த வேண்டும். அதனால் அவை இரண்டு <DT>blocks</DT> ஆக வரும்.
+
+55
+00:05:24,810 --> 00:05:27,550
+அந்த 13, 32 மற்றும் 22 <DT>left</DT> பக்கம் வரும்.
+
+56
+00:05:27,550 --> 00:05:33,430
+63 57, 91 மற்றும் 78, <DNT>right</DNT> மற்றும் <DT>pivot element</DT> 43 <DT>middle</DT> ல் வருகிறது.
+
+57
+00:05:33,947 --> 00:05:36,781
+இது <DT>rearranging step</DT> மற்றும் இப்போது
+
+58
+00:05:37,060 --> 00:05:41,529
+நாம் <DNT>yellow bits</DNT> மற்றும் <DNT>green bits</DNT> ஆகியவற்றை <DT>recursively sort</DT> செய்வோம். பிறகு அதைச் செய்யலாம் என்று கருதினால்,
+
+59
+00:05:41,529 --> 00:05:45,480
+ந���்மிடம் ஒரு <DT>sorted array</DT> உள்ளது மற்றும் அனைத்து <DNT>yellow</DNT> பொருட்களும் <DT>smaller than </DT>43 ஆக இருப்பதை கவனிக்கவும்.
+
+60
+00:05:45,480 --> 00:05:49,509
+மேலும் அனைத்து <DNT>green</DNT> விஷயங்களும் <DT>bigger than</DT> 43. மேலும் <DT>merging</DT> செய்ய தேவையில்லை.
+
+61
+00:05:52,243 --> 00:05:54,899
+எனவே, <DT>partitioning</DT> எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்.
+
+62
+00:05:54,899 --> 00:05:59,350
+இங்கே நம்மிடம் முந்தைய <DT>list</DT> ல் உள்ளது. மேலும் 43 ஐ நமது <DT>pivot element</DT> ஆக <DT>marked </DT> செய்துள்ளோம்.
+
+63
+00:05:59,350 --> 00:06:03,112
+மீதமுள்ள <DT>elements</DT> களை <DT>scan</DT> செய்து அவற்றை <DT>divide</DT> செய்ய விரும்புகிறோம்.
+
+64
+00:06:03,137 --> 00:06:08,742
+இரண்டு குழுக்கள், <DT>smaller than</DT> 43, <DNT>yellow ones</DNT>, <DT>bigger than</DT> 43, <DNT>green ones</DNT> மற்றும் அவற்றை <DT>rearrange</DT> செய்யவும்.
+
+65
+00:06:09,962 --> 00:06:13,839
+நாம் என்ன செய்வோம் இரண்டு <DT>pointers</DT> கள் <DNT>yellow pointer</DNT> மற்றும் <DNT>green pointer</DNT> ஐ வைத்திருப்போம்.
+
+66
+00:06:14,155 --> 00:06:19,081
+மேலும் பொதுவான விதி என்னவென்றால், எந்த ஒரு <DT>point</DT>லும் நாம் சிறிது <DT>distance</DT> ல் இருப்போம்.
+
+67
+00:06:19,355 --> 00:06:24,129
+நான் <DNT>orange</DNT> நிறத்தில் வரையப் போகும் <DT>visible</DT> <DNT>yellow pointer</DNT> மற்றும் <DNT>green pointer</DNT>.
+
+68
+00:06:24,129 --> 00:06:29,165
+இவை இந்த <DT>order</DT> ல் நகரும் <DNT>orange pointer</DNT> அல்லது <DNT>yellow pointer</DNT> எப்போதும் <DNT>green pointer</DNT> பின்னால் இருக்கும்.
+
+69
+00:06:29,565 --> 00:06:35,397
+நீங்கள் பராமரிக்கும் <DT>inductive property</DT> என்னவென்றால், இந்த <DT>elements</DT> கள் 43 ஐ விட <DT>smaller than</DT> அல்லது சமமாகவோ இருக்கும்.
+
+70
+00:06:35,910 --> 00:06:40,643
+இந்த <DT>elements</DT> கள் <DT>bigger than</DT> 43 மற்றும் இந்த <DT>elements</DT> கள் <DT>தெரியவில்லை</DT>.
+
+71
+00:06:42,577 --> 00:06:46,139
+நாம் செய்ய முயற்சிப்பது என்னவென்றால், <DT>left</DT> ல் இருந்து <DNT>right</DNT> க்கு நகர்த்த முயற்சிக்கிறோம்.
+
+72
+00:06:46,139 --> 00:06:49,589
+ஒவ்வொரு முறையும் <DT>unknown elements</DT> ஐ காணும் அனைத்து <DT>unknown elements</DT> களையும் <DT>classify</DT> செய்யவும்.
+
+73
+00:06:49,552 --> 00:06:52,660
+இந்த property ஐ நாம் maintain பண்ண இரண்டு <DT>pointers</DT> களை மாற்றுவோம்.
+
+74
+00:06:52,700 --> 00:06:57,699
+43 க்கும் முதல் <DT>pointer</DT> க்கும் இடையில் <DT>elements smaller than</DT> 43 அல்லது அதற்கு சமமாக உள்ளன.
+
+75
+00:06:57,699 --> 00:07:01,494
+முதல் <DT>pointer</DT> க்கும் இரண்டாவது <DT>pointer</DT> க்கும் இடையில் நம் <DT>elements</DT> கள் கண்டிப்பாக 43 க்கு <DT>greater</DT> ஆக உள்ளது.
+
+76
+00:07:01,752 --> 00:07:05,230
+மற்றும் <DNT>green pointer</DNT> இன் <DNT>right</DNT> பக்கம் இன்னும் <DT>scanned</DT> செய்யப்படாதவை  உள்ளன.
+
+77
+00:07:07,023 --> 00:07:10,000
+எனவே, ஆரம்பத்தில் எதுவும் தெரியவில்லை. பின்னர் நாம் 32 ஐ பார்க்கிறோம்.
+
+78
+00:07:10,000 --> 00:07:14,618
+32 43 ஐ விட <DT>smaller than</DT> ஆக இருப்பதால், <DNT>yellow pointer</DNT> ஐ நகர்த்துகிறோம். மேலும் <DNT>green pointer</DNT> ஐ உடன் தள்ளுகிறோம்.
+
+79
+00:07:14,643 --> 00:07:16,949
+தெரியாத விஷயம் 22 இல் தொடங்குகிறது.
+
+80
+00:07:16,949 --> 00:07:22,060
+<DNT>yellow</DNT> மற்றும் <DNT>green pointer</DNT> ஆகியவற்றுக்கு இடையே எதுவும் இல்லை. <DT>value bigger than</DT> 43 ஐ நாம் இன்னும் கண்டுபிடிக்கவில்லை.
+
+81
+00:07:22,949 --> 00:07:24,910
+எனவே, 22 க்கும் அதே நடக்கும்.
+
+82
+00:07:24,910 --> 00:07:28,629
+இப்போது, 78ஐ பார்க்கும்போது, 78 <DT>bigger than</DT> 43 என்பதைக் கவனிக்கிறோம்.
+
+83
+00:07:29,008 --> 00:07:33,635
+இப்போது, நாம் <DNT>green pointer</DNT> ஐ மட்டுமே நகர்த்துகிறோம். மேலும் <DNT>yellow pointer</DNT> ஐ அல்ல. இப்போது, இந்த 3 இடைவெளிகளை முன்பு போலவே வைத்திருக்கிறோம்.
+
+84
+00:07:33,935 --> 00:07:36,819
+இது 43 க்கு குறைவான <DT>equal</DT> ஆன பகுதி என்பதை நினைவில் கொள்ளுங்கள்.
+
+85
+00:07:36,819 --> 00:07:44,350
+இது <DT>greater than</DT> 43 உள்ள பகுதி மற்றும் இந்த பகுதி unknown <DNT>right</DNT>, நாம் இந்த வழியில் தொடர்கிறோம்.
+
+86
+00:07:44,350 --> 00:07:48,189
+இப்போது நாம் 63 ஐ பார்க்கிறோம். மீண்டும் 63 <DNT>green zone</DNT> ஐ நீட்டிக்கிறது.
+
+87
+00:07:48,189 --> 00:07:52,540
+57 ஒரு <DNT>green zone</DNT> ஐ நீட்டிக்கிறது 91 ஒரு <DNT>green zone</DNT> ஐ நீட்டிக்கிறது.
+
+88
+00:07:52,540 --> 00:07:56,470
+இப்போது, 13 ஐ கண்டுபிடிக்கும்போது நாம் ஏதாவது செய்ய வேண்டும்.
+
+89
+00:07:56,470 --> 00:08:00,100
+13 என்பது இப்போது <DNT>yellow zone</DNT> ல் சேர்க்கப்பட வேண்டிய ஒரு <DT>element</DT>.
+
+90
+00:08:00,205 --> 00:08:03,705
+ஒரு <DT>strategy</DT> நிறைய மாற்றங்களைச் செய்ய வேண்டும்.
+
+91
+00:08:03,730 --> 00:08:07,360
+நாம் 13 ஐ 22 இருக்கும் இடத்திற்கு அல்லது 22 க்குப் பிறகு நகர்த்துகிறோம்.
+
+92
+00:08:07,360 --> 00:08:10,180
+மேலும் 78 இல் இருந்து எல்லாவற்றையும் <DNT>right</DNT> க்கு தள்ளுகிறோம்.
+
+93
+00:08:10,250 --> 00:08:15,220
+ஆனால் உண்மையில், ஒரு புத்திசாலித்தனமான <DT>strategy</DT> என்னவென்றால், 13 இங்கே செல்ல வேண்டும் என்று சொல்வது.
+
+94
+00:08:17,605 --> 00:08:21,519
+நாம் space ஐ உருவாக்க வேண்டும். ஆனால் <DT>space</DT> ஐ உருவாக்குவதற்கு பதிலாக.
+
+95
+00:08:21,519 --> 00:08:30,399
+எப்படியும் <DNT>green</DNT> விஷயங்களை நாம் <DT>sort</DT> செய்யபோகிறோம். அது  ஒரு பொருட்டல்ல என்று சொல்லலாம். இரண்டையும் எந்த வழியில் <DT>sort</DT> செய்கிறோம் என்பது எப்படி முக்கியம்.  இந்த 78ஐ எடுத்து 13க்கு நகர்த்துவோம்.
+
+96
+00:08:30,399 --> 00:08:33,009
+எந்த மாற்றத்தையும் செய்வதற்கு பதிலாக.
+
+97
+00:08:33,009 --> 00:08:36,370
+<DNT>green</DNT> zone ல் முதல் <DT>element</DT> ஐ <DT>exchange</DT> செய்கிறோம்.
+
+98
+00:08:36,370 --> 00:08:38,320
+நாம் இதுவரை பார்க்கும் <DT>element</DT> உடன்.
+
+99
+00:08:38,320 --> 00:08:41,980
+அது தானாகவே <DNT>yellow zone</DNT> மற்றும் <DNT>green zone</DNT> இரண்டையும் சரியாக நீட்டிக்கும்.
+
+100
+00:08:42,080 --> 00:08:49,299
+நமது அடுத்த <DT>step</DT> 13 <DT>smaller than</DT> 43 என்பதை கண்டறிந்து, அதை 73 உடன் <DT>இடமாற்று</DT> செய்வது.
+
+101
+00:08:49,399 --> 00:08:54,070
+இப்போது, நம்மிடம் உள்ள <DT>pivot</DT> ன் <DNT>right</DNT> க்கு ஒரு <DT>intermediate stage</DT> ஐ அடைந்துள்ளோம்.
+
+102
+00:08:54,070 --> 00:08:58,360
+எல்லாவற்றையும் scanned செய்து, அவற்றை <DT>smaller</DT> ஆக வகைப்படுத்தியுள்ளோம்.
+
+103
+00:08:58,360 --> 00:08:59,889
+மற்றும் <DT>bigger</DT> ஐயும்.
+
+104
+00:09:00,716 --> 00:09:04,216
+இப்போது, <DNT>yellow</DNT> விஷயங்களை 43க்கு <DT>left</DT> பக்கம் <DT>push</DT> செய்ய வேண்டும்.
+
+105
+00:09:05,036 --> 00:09:09,165
+இப்போது, <DNT>yellow zone</DNT> ல் 13ஐ சேர்த்தபோது பார்த்த அதே <DT>problem</DT> மீண்டும் ஒருமுறை நமக்கு வந்துள்ளது.
+
+106
+00:09:09,190 --> 00:09:13,210
+நாம் 43 ஐ சரியான இடத்திற்கு நகர்த்தினால், இங்கே அனைத்தையும் <DNT>left</DNT> க்கு நகர்த்த வேண்டும்.
+
+107
+00:09:13,404 --> 00:09:18,940
+ஆனால், அதற்குப் பதிலாக இந்த 13ஐ <DNT>yellow zone</DNT> ல் கடைசி <DT>element</DT> ஆக எடுத்துக்கொள்ளலாம்.
+
+108
+00:09:18,940 --> 00:09:22,149
+மற்றும் அதை அங்கே <DT>replace</DT> செய்யவும். 32 மற்றும் 22 ஐ shift செய்ய வேண்டாம்.
+
+109
+00:09:22,149 --> 00:09:26,759
+இது <DT>order</DT> ஐ சீர்குலைக்கிறது. ஆனால் எப்படியும் இது <DT>unsorted</DT> செய்யாமல், <DT>unsorted</DT> ஆக உள்ளது.
+
+110
+00:09:27,632 --> 00:09:29,889
+நாம் இதை செய்கிறோம். இப்போது நம்மிடம் உள்ளது.
+
+111
+00:09:30,001 --> 00:09:36,171
+நாம் விரும்பியபடி <DT>array rearranged</DT> செய்யப்பட்டது.  எனவே, <DT>left</DT> ல் உள்ள இவை அனைத்தும் <DT>smaller than</DT> <DT>pivot</DT>.
+
+112
+00:09:37,244 --> 00:09:41,856
+<DT>pivot</DT> நடுவில் உள்ளது.  மற்றும் <DNT>right</DNT> ல் உள்ள அனைத்தும் <DT>bigger than</DT> <DT>pivot</DT>.
+
+113
+00:09:46,550 --> 00:09:53,830
+இங்கே <DT>python</DT> இன் ஒரு <DT>implementation</DT> உள்ளது. <DT>quick sort</DT> என்பது  <DT>merge sort </DT> மற்றும் <DT>binary research</DT> போன்றவற்றைக் கொண்டிருக்கும் என்பதை நினைவில் கொள்ளவும்.
+
+114
+00:09:53,830 --> 00:09:58,690
+<DT>smaller</DT> மற்றும் <DT>smaller segments</DT> ல் அதை மீண்டும் மீண்டும் பயன்படுத்துகிறோம். பொதுவாக நாம் அதை <DT>pass</DT> செய்யவும்.
+
+115
+00:09:58,690 --> 00:10:03,523
+நாம் <DNT>call A</DNT> என்ற <DT>list</DT> க்கும், <DT>segment</DT> ன் <DT>end points</DT> ஆன <DNT>left</DNT> மற்றும் <DNT>right</DNT>.
+
+116
+00:10:03,548 --> 00:10:07,238
+நாம் ஒரு <DNT>slice l </DNT> முதல் <DNT>r minus 1</DNT> வரை செய்கிறோம்.
+
+117
+00:10:08,244 --> 00:10:13,210
+இந்த <DT>slice</DT> 1 அல்லது 0 <DT>length</DT> ஆக இருந்தால், நாம் எதுவும் செய்ய மாட்டோம்.
+
+118
+00:10:14,223 --> 00:10:17,320
+இல்லையெனில், நாம் முன்பு இருந்த இந்த <DT>partitioning strategy</DT> ஐ பின்பற்றுவோம்.
+
+119
+00:10:17,708 --> 00:10:22,120
+அதாவது <DNT>l</DNT> இலிருந்து <DNT>r minus 1</DNT> வரை <DT>sorting</DT> செய்கிறோம்.
+
+120
+00:10:22,120 --> 00:10:24,220
+எனவே, <DT>position l</DT>.
+
+121
+00:10:24,379 --> 00:10:25,899
+இது <DT>pivot</DT> ஆகும்.
+
+122
+00:10:26,793 --> 00:10:29,671
+<DNT>right</DNT> முதலில் இங்கே <DNT>yellow pointer</DNT> ஐ வைப்போம்.
+
+123
+00:10:31,011 --> 00:10:33,635
+<DNT>yellow zone</DNT> இன் முடிவு என்று கூறுகிறது.
+
+124
+00:10:34,005 --> 00:10:38,500
+உண்மையில் <DT>pivot</DT> உள்ளது அங்கு எதுவும் இல்லை. <DNT>yellow</DNT> என்பது <DNT>l plus 1</DNT> ஆகும்.
+
+125
+00:10:38,500 --> 00:10:50,781
+இப்போது <DNT>green</DNT>ஐ தொடர அனுமதிக்கிறோம். ஒவ்வொரு <DT>time</DT>ம் <DNT>green</DNT> இல் ஒரு <DT>element</DT> ஐ பார்க்கும்போது புதிய <DNT>green</DNT> ஒன்���ைக் காட்டிலும் <DT>smaller than</DT> ஆக இருக்கும் <DT>pivot</DT> ஆகும். இது <DT>pivot</DT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+126
+00:10:51,965 --> 00:10:55,661
+<DNT>right</DNT> நாம் எப்போதாவது ஒரு <DNT>green</DNT> ஐ பார்த்தால், அடுத்த <DT>value</DT> ஐ.
+
+127
+00:10:55,686 --> 00:10:57,580
+சரிபார்க்கப்பட வேண்டியதை விட <DT>smaller than</DT> அல்லது சமமானது.
+
+128
+00:10:57,590 --> 00:11:01,714
+நாம் <DT>exchange</DT> செய்கிறோம். இதனால் இந்த <DT>value</DT> ஐ <DNT>yellow zone</DNT> ன் முடிவுக்குக் கொண்டு வருகிறோம்.
+
+129
+00:11:01,739 --> 00:11:03,220
+இதைத்தான் 13ல் செய்தோம்.
+
+130
+00:11:03,344 --> 00:11:07,590
+பின்னர், <DNT>yellow pointer</DNT> ஐ நகர்த்துகிறோம். இல்லையெனில் கண்டிப்பாக <DT>bigger</DT> <DT>value</DT> ஐ கண்டால் நகர்த்துவோம்.
+
+131
+00:11:07,590 --> 00:11:11,860
+<DNT>green pointer</DNT> மட்டுமே <DT>for loop</DT> ஆல் மறைமுகமாக செய்யப்படுகிறது. மற்றொன்றை நகர்த்த மாட்டோம்.
+
+132
+00:11:11,929 --> 00:11:14,883
+இதன் முடிவில் நமக்கு <DT>pivot</DT> உள்ளது.
+
+133
+00:11:15,894 --> 00:11:19,784
+நாம் <DT>pivot</DT> க்கு சமமானதைக் காட்டிலும் குறைவானதைக் கொண்டுள்ளோம். பின்னர் <DT>greater than pivot</DT> ம் கொண்டுள்ளோம்.
+
+134
+00:11:19,809 --> 00:11:27,914
+இந்த விதியின் முடிவில் நாம் அடைந்த அந்த intermediate stage இதுதான். இப்போது, நாம் <DT>pivot</DT> ஐ கண்டுபிடித்து சரியான இடத்திற்கு நகர்த்த வேண்டும். எனவே, <DNT>yellow</DNT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+135
+00:11:29,241 --> 00:11:32,769
+<DNT>yellow</DNT> <DNT>last</DNT> க்கு அப்பால் உள்ள <DT>position</DT> ஐ சுட்டிக்காட்டுகிறது.
+
+136
+00:11:32,769 --> 00:11:37,440
+<DT>element அதை விட சிறியது</DT>. <DNT>yellow</DNT> இதற்கு முன் எப்போதும் ஒரு <DT>value</DT> ஆகும்.
+
+137
+00:11:37,440 --> 00:11:40,396
+<DNT>yellow</DNT> minus 1 இன் <DT>value</DT> ஐ எடுத்து, <DT>left value</DT> உடன் <DT>exchange</DT> செய்வோம்.
+
+138
+00:11:41,414 --> 00:11:48,765
+இப்போது நாம் செய்ய வேண்டியது என்னவென்றால், நம்மிடம் இப்போது <DNT> p, p and greater than p</DNT> ஐ விட குறைவாக உள்ளது.
+
+139
+00:11:49,627 --> 00:12:01,350
+இங்குதான் <DNT>yellow</DNT> <DNT>சரியானது</DNT>. நாம் 0 இலிருந்து <DNT>yellow</DNT> minus 1 க்கு செல்ல வேண்டும். மீண்டும் <DNT>sort p </DNT> ஐ விரும்பவில்லை. ஏனெனில் <DNT>p</DNT> ஏற்கனவே சரியான இடத்தில் வைக்கப்பட்டுள்ளது.
+
+140
+00:12:01,350 --> 00:12:06,391
+<DNT>L</DNT> இலிருந்து <DNT>yellow</DNT> minus 1 ஆகவும், <DNT>yellow</DNT> இலிருந்து <DNT>right</DNT> முனையிலும் <DT>quick sort</DT> செய்வோம்.
+
+141
+00:12:13,070 --> 00:12:17,070
+<DT>slide</DT> ல் பார்த்த <DT>python code</DT> ஐ இங்கே ஒரு <DT>file</DT> ல் எழுதியுள்ளோம்.
+
+142
+00:12:17,070 --> 00:12:20,320
+slide ல் இருந்த அதே <DT>code</DT> இதுதானா என்பதை சரிபார்க்கலாம்.
+
+143
+00:12:20,345 --> 00:12:28,786
+நாம் அதை முயற்சி செய்து <DT>run</DT> செய்யலாம் மற்றும் அது செயல்படுகிறதா என்று சரிபார்க்கலாம். <DT>call python</DT>, இந்த <DT>function</DT> ஐ <DT>import</DT> செய்கிறோம்.
+
+144
+00:12:32,849 --> 00:12:37,699
+இது மீண்டும் ஒரு வகையான <DT>sorts</DT> <DT>function</DT> என்பதை நினைவில் கொள்ளுங்கள். எதையாவது <DT>sort</DT> செய்து அதன் விளைவைப் பார்க்க விரும்பினால்.
+
+145
+00:12:37,753 --> 00:12:40,870
+நாம் அதற்கு ஒரு <DT>name</DT> ஐ <DT>assign</DT> செய்ய வேண்டும். பின்னர் அந்த <DT>name</DT> ஐ <DT>sort</DT> செய்து, பிறகு <DT>name</DT> ஐ சரிபார்க்க வேண்டும்.
+
+146
+00:12:40,909 --> 00:12:48,137
+எடுத்துக்காட்டாக, 500 முதல் 0 வரையிலான <DT>range</DT> of <DT>values</DT> ஐ எடுத்துக் கொள்வோம்.
+
+147
+00:12:50,287 --> 00:12:58,090
+இப்போது நாம் <DNT>quicksort l</DNT> என்று சொன்னால், அதற்கு <DNT>of course</DNT> முடிவைக் கொடுக்க வேண்டும்.
+
+148
+00:13:01,020 --> 00:13:02,468
+பிறகு <DNT>l</DNT> சரியாக <DT>sorted</DT> செய்யப்படும்.
+
+149
+00:13:04,311 --> 00:13:09,523
+நீங்கள் அனைத்தையும் பார்க்க முடியாது. ஆனால்  83 84 முதல் நூறு வரை மற்றும் இரண்டு 500 வரை பார்க்க முடியும்.
+
+150
+00:13:10,995 --> 00:13:16,480
+இப்போது, 1000 என்று சொன்னால், <DT>insertion sort</DT> ல் நமக்கு இருந்த அதே <DT>problem</DT> உள்ளது.
+
+151
+00:13:17,897 --> 00:13:22,596
+பின்னர் நாம் இதை <DT>quicksort</DT> செய்ய முயற்சிக்கிறோம். நீங்கள் இதை <DT>recursion depth</DT> ஆல் பெறுவீர்கள்.
+
+152
+00:13:22,621 --> 00:13:29,644
+<DT>worst case</DT> ல் நாம் பார்ப்பது போல, <DT>quick sort</DT> ஆனது <DT>insertion sort</DT> ஐ போலவே செயல்படுகிறது மற்றும் இது மோசமான case.
+
+153
+00:13:29,669 --> 00:13:33,759
+இதைப் போக்க, நாம் வழக்கமான காரியத்தைச் செய்ய வேண்டும். <DT>SYS module</DT> ஐ <DT>import</DT> செய்ய வேண்டும்.
+
+154
+00:13:33,759 --> 00:13:35,409
+<DT>recursion limit</DT> ஐ <DT>set</DT> செய்யவும்.
+
+155
+00:13:36,658 --> 00:13:43,652
+எனவே, பொருத்தமான பெரிய ஒன்று பத்தாயிரம் அல்லது நூறாயிரம் என்று சொல்லுங்கள். பின்னர் அதை <DT>quicksort</DT> செய்ய சொன்னால் எந்த problem உம்  இல்லை.
+
+156
+00:13:44,779 --> 00:13:49,299
+<DT>python</DT> ல் இந்த <DT>recursion limit</DT> ஐ manually set செய்ய வேண்டிய மற்றொரு case இதுவாகும்.
+
+157
+00:13:49,647 --> 00:13:56,929
+உண்மையில் நாம் பார்க்கக்கூடிய ஒரு விஷயம் என்னவென்றால், <DT>quicksort</DT> என்பது நாம் நம்புவது போல் நல்லதல்ல, ஏனெனில்.
+
+158
+00:13:57,008 --> 00:14:02,080
+எடுத்துக்காட்டாக, 7500 என்று ஏதாவது <DT>size</DT> ஐ <DT>instance sort</DT> செய்யவும்.
+
+159
+00:14:05,504 --> 00:14:09,554
+பின்னர் அது ஒரு புலப்படும் நேரம் எடுக்கும். எனவே, <DNT>n log n</DNT> என்று <DT>merge sort </DT> ஐ பார்த்தோம்.
+
+160
+00:14:09,790 --> 00:14:13,700
+5,000 மற்றும் 10000 மற்றும் 100,000 கூட <DT>instantaneously</DT> செய்யும்.
+
+161
+00:14:13,832 --> 00:14:18,129
+தெளிவாக <DT>quick sort</DT> மற்றும் <DT>merge sort </DT> செயல்படாது.
+
+162
+00:14:18,165 --> 00:14:22,480
+மற்றும் உண்மையில் <DT>quick sort</DT> க்கு <DT>order</DT> <DNT>n log n</DNT> <DT>merge sort </DT> இல்லை என்பதை நாம் பார்ப்போம்.
+
+163
+00:14:22,511 --> 00:14:25,090
+நாம் விரும்பியபடி நடத்தை.
+
+164
+00:14:25,090 --> 00:14:28,539
+அதற்குக் காரணம், நாம் <DT>median</DT> ஐ பயன்படுத்தாமல், split செய்வதற்கான முதல் <DT>value</DT> ஐ பயன்படுத்துகிறோம்.
+
+165
+00:14:28,539 --> 00:14:33,909
+அதை அடுத்த lecture ல் பார்ப்போம்.  ஏன் <DT>quick sort</DT> ல் உண்மையி���் ஒரு worst case <DNT>order n log n algorithm</DNT> அல்ல.

Translated_SRT/Week4_Lecture3_Cleaned_Tagged.ta.srt

@@ -0,0 +1,660 @@
+1
+00:00:02,246 --> 00:00:06,190
+<DT>merge sort </DT> என்பது <DT>order</DT> <DNT>n log n</DNT> <DT>sorting algorithm</DT> என்று பார்த்தோம்.
+
+2
+00:00:06,190 --> 00:00:10,509
+ஆனால் இது சில குறைபாடுகளைக் கொண்டுள்ளது. இது சில நேரங்களில் <DT>impractical</DT> ஆகிறது.
+
+3
+00:00:10,849 --> 00:00:14,740
+முக்கிய பிரச்சனை என்னவென்றால், <DT>merging</DT> க்கு <DT>extra space</DT> தேவைப்படுகிறது.
+
+4
+00:00:14,869 --> 00:00:19,076
+<DT>recursion</DT> ஐ பயன்படுத்தாமல் <DT>implement merge sort </DT> செய்வது கடினம் என்பதையும் நாம் பார்த்தோம்.
+
+5
+00:00:19,101 --> 00:00:22,108
+மற்றும் <DT>recursion</DT> <DT>programming language</DT> ல் அதன் சொந்த செலவைக் கொண்டுள்ளது.
+
+6
+00:00:24,841 --> 00:00:26,952
+எனவே, <DT>space problem</DT> ஐ தீர்க்கலாம்.
+
+7
+00:00:27,736 --> 00:00:33,310
+<DT>merge function</DT> ஐ <DT>implement</DT> செய்யும் <DT>பொருட்டு</DT>, <DT>merge sort </DT> க்கு <DT>extra space</DT> தேவைப்படுகிறது.
+
+8
+00:00:33,590 --> 00:00:38,500
+நாம் ஏன் <DT>merge</DT> செய்ய வேண்டும்?  நாம் <DT>merge</DT> செய்ய வேண்டியதன் காரணம், நாம் <DT>merge sort </DT> ஐ செய்யும்போது,
+
+9
+00:00:38,500 --> 00:00:45,759
+நம்மிடம் <DT>initial list</DT> உள்ளது. பின்னர் அதை இரண்டு பகுதிகளாக split செய்கிறோம். ஆனால், பொதுவாக <DT>left</DT> இலிருந்து <DT>items</DT> கள் இருக்கலாம்.
+
+10
+00:00:45,759 --> 00:00:50,409
+<DNT>right</DNT> இலிருந்து <DT>bigger than items</DT>. எனவே, <DT>instance</DT> ஆக நாம் சொன்னால்,
+
+11
+00:00:50,450 --> 00:00:54,250
+<DT>left</DT> ல் <DT>even numbers</DT> மற்றும் <DNT>right</DNT> ல் <DT>odd numbers</DT>.
+
+12
+00:00:54,550 --> 00:00:58,900
+இரண்டு பக்கங்களிலிருந்தும் <DT>numbers alternately</DT> எடுத்துக்கொண்டு <DT>merge</DT> செய்ய வேண்டும்.
+
+13
+00:00:59,630 --> 00:01:09,646
+<DT>divided problem</DT> ன் <DT>left</DT> பக்கத்தில் உள்ள அனைத்தும் <DT>divided problem</DT> ன் <DNT>வலது</DNT> பக்கத்தில் உள்ள அனைத்தையும் விட சிறியதாக இருக்கும்படி <DT>arrange</DT> செய்தால்,
+
+14
+00:01:10,593 --> 00:01:12,146
+பின்னர், நாம் அனைத்தையும் <DT>merge</DT> செய்ய தேவையில்லை.
+
+15
+00:01:12,699 --> 00:01:18,130
+மேலும் இது <DT>merge</DT> செய்வதற்கு, கூடுதல் space தேவைப்படும் <DT>problem</DT> ஐ தவிர்க்கலாம்.
+
+16
+00:01:20,689 --> 00:01:23,702
+<DT>merge</DT> இல்லாமல் எப்படி <DT>divide</DT> மற்றும் <DT>conquer</DT> செய்வது.
+
+17
+00:01:25,243 --> 00:01:27,659
+<DT>median value</DT> நமக்குத் தெரியும் என்று வைத்துக்கொள்வோம்.
+
+18
+00:01:27,659 --> 00:01:33,716
+ஒரு <DT>set</DT> ல் உள்ள <DT>median value</DT> என்பது <DT>half</DT> the <DT>elements</DT> are <DT>smaller than half</DT> are <DT>bigger</DT> ஆக இருக்கும் <DT>value</DT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+19
+00:01:35,649 --> 00:01:42,124
+<DT>median</DT> விட <DT>smaller than</DT> <DT>values</DT> அனைத்தையும் <DT>left half</DT> க்கும், <DT>median</DT> விட <DT>bigger than</DT> அனைத்தையும் <DNT>right half</DNT> க்கும் நகர்த்தலாம்.
+
+20
+00:01:43,883 --> 00:01:52,180
+நாம் பார்ப்பது போல, <DT>list</DT> ன் <DT>length</DT> க்கு <DT>time proportional</DT> ஆக புதிய <DT>array</DT> வை உருவாக்காமல் இதைச் செய்யலாம்.
+
+21
+00:01:53,816 --> 00:02:00,989
+இந்த <DT>rearrangement</DT> ஐ செய்த பிறகு, அனைத்து <DT>smaller values</DT> களையும் <DT>left half</DT> க்கும் <DT>bigger values</DT> களை <DNT>right half</DNT> க்கும் நகர்த்தவும்.
+
+22
+00:02:00,989 --> 00:02:06,443
+இந்த <DT>divide</DT> மற்றும் <DT>conquer strategy</DT> ஐ நாம் <DT>recursively</DT> பயன்படுத்தலாம். மேலும் <DNT>right</DNT> மற்றும் <DT>left half</DT> ஐ தனித்தனியாக <DT>sort</DT> செய்யலாம்.
+
+23
+00:02:07,519 --> 00:02:12,520
+மேலும் <DT>left half</DT> ல் உள்ள அனைத்தும், <DNT>right half</DNT> ல் உள்ள அனைத்தையும் விட <DT>சிறியது</DT> என்று நாம் உத்தரவாதம் அளித்துள்ளோம்.
+
+24
+00:02:13,019 --> 00:02:17,050
+இது தானாகவே இதற்கு அர்த்தம் <DT>divide</DT> மற்றும் <DT>conquer</DT> step க்கு பிறகு,
+
+25
+00:02:17,050 --> 00:02:24,442
+<DT>left half</DT> ஏற்கனவே <DNT>right half</DNT> க்கு கீழே இருப்பதால், non-trivial முறையில் answers களை combine செய்ய வேண்டிய அவசியமில்லை. நாம் <DT>merge</DT> செய்ய தேவையில்லை.
+
+26
+00:02:28,309 --> 00:02:34,210
+இந்த <DT>strategy</DT> ஐ பயன்படுத்தினால், <DT>merge sort </DT> போன்ற ஒரு <DT>recursive equation</DT> ஐ பெறுவோம்.
+
+27
+00:02:34,210 --> 00:02:42,370
+<DNT>length n</DNT> இன் <DT>list</DT> ஐ <DT>sort</DT> செய்வதற்கு <DT>time</DT> தேவைப்படும். முதலில் <DNT>size n</DNT> இன் இரண்டு <DT>lists</DT> களை 2 ஆல் <DT>sort</DT> செய்ய வேண்டும்.
+
+28
+00:02:42,370 --> 00:02:50,039
+நாம் <DNT>order n </DNT> ஐ செய்வோம் <DT>merging</DT> ஆக அல்ல.  <DT>list</DT> ஐ <DT>decompose</DT> செய்வதற்காக. அதனால் அனைத்து <DT>smaller values</DT> களும் <DT>left</DT> மற்றும் <DNT>right</DNT> இல் இருக்கும்.
+
+29
+00:02:50,064 --> 00:02:54,483
+நாம் <DT>recursive step</DT> செய்வதற்கு முன் rearranging <DT>step</DT> <DNT>order n</DNT> ஆகும்.
+
+30
+00:02:54,508 --> 00:02:57,879
+அதேசமயம் <DT>merge</DT> என்பது <DT>recursive step</DT> க்கு பின் வரும் <DT>step</DT> ஆகும்.
+
+31
+00:02:57,879 --> 00:03:03,879
+இது முந்தைய <DT>case</DT> ல் <DNT>order n</DNT> ஆக இருந்தது. ஆனால் நாம் <DT>recurrence</DT> ஐ <DT>solve</DT>செய்தால் அதே ஒன்றுதான். நமக்கு மற்றொரு <DNT>order n log n algorithm</DNT> கிடைக்கும்.
+
+32
+00:03:08,730 --> 00:03:12,340
+இந்த <DT>approach</DT> இல் பெரிய <DT>bottleneck</DT> என்னவென்றால் <DT>median</DT> ஐ கண்டறிவதாகும்.
+
+33
+00:03:13,190 --> 00:03:20,663
+ஒரு <DT>list</DT> ஐ <DT>sorting</DT> செய்வதன் நன்மைகளில் ஒன்று, <DT>sorting</DT> க்கு பின் <DT>median</DT> ஐ  middle <DT>element</DT> ஆக நாம் அடையாளம் காணலாம் என்பதை நினைவில் கொள்ளுங்கள்.
+
+34
+00:03:21,890 --> 00:03:24,336
+இப்போது, இங்கே நாம் <DT>sorting</DT> செய்வதற்கு முன் <DT>median</DT> ஐ கேட்கிறோம்.
+
+35
+00:03:24,996 --> 00:03:28,539
+ஆனால், நமது நோக்கம் <DT>sort</DT> செய்வது. அது <DT>paradoxical</DT> ஆகும்.
+
+36
+00:03:28,539 --> 00:03:33,219
+<DT>sorting</DT>ன் <DT>output</DT> <DT>sorting</DT> ஆன <DT>input</DT> ஆக இருக்க வேண்டும் என நாம் விரும்பினால்.
+
+37
+00:03:34,892 --> 00:03:42,580
+எனவே, <DT>list</DT> ஐ <DNT>split</DNT> செய்து <DT>element</DT> ன் மிகவும் எளிமையான தேர்வு மூலம் <DT>strategy</DT> யை முயற்சிக்க வேண்டும் என்பதே இதன் பொருள்.
+
+38
+00:03:42,825 --> 00:03:46,780
+<DT>median</DT> ஐ தேடுவதற்குப் பதிலாக, <DNT>list A</DNT> இல் சில <DT>value</DT> ஐ பெறுவோம்.
+
+39
+00:03:46,780 --> 00:03:49,689
+மற்றும் <DT>pivot element</DT> என அழைக்கப்படுவதைப் பயன்படுத்தவும்.
+
+40
+00:03:49,689 --> 00:03:56,769
+இந்த <DT>pivot</DT> ஐ பொறுத்து <DNT>A</DNT> என்று பிரிக்கிறோம். இதன���ல் அனைத்து <DT>smaller elements</DT> களும் <DT>left</DT> ஆகவும், <DT>bigger elements</DT> கள் அனைத்தும் <DNT>right</DNT> ஆகவும் இருக்கும்.
+
+41
+00:04:00,223 --> 00:04:11,636
+இந்த <DT>algorithm</DT> <DT>quick sort</DT> என்று அழைக்கப்படுகிறது. இது 1960 களில் <DT>Tony Four</DT> என்ற நபரால் கண்டுபிடிக்கப்பட்டது மற்றும் இது மிகவும் பிரபலமான <DT>sorting algorithms</DT> களில் ஒன்றாகும்.
+
+42
+00:04:12,103 --> 00:04:16,082
+பொதுவாக <DT>array</DT> இன் <DT>list</DT> ல் முதல் <DT>element</DT> ஆக இருக்கும் <DT>pivot element</DT> ஐ தேர்வு செய்கிறோம்.
+
+43
+00:04:16,759 --> 00:04:22,500
+இந்த <DT>pivot</DT> இன் முடிவைப் பொறுத்து <DT>lower part</DT> லும் <DT>upper part</DT> லும் <DNT>partition A</DNT> செய்கிறோம்.
+
+44
+00:04:22,500 --> 00:04:24,943
+எனவே, அனைத்து <DT>smaller elements</DT> களையும் <DT>left</DT> க்கு நகர்த்துகிறோம்.
+
+45
+00:04:25,056 --> 00:04:28,149
+மற்றும் அனைத்து <DT> bigger elements</DT> முதல் <DNT>right</DNT> வரை <DT>pivotal</DT> தேர்வைப் பொறுத்து.
+
+46
+00:04:29,523 --> 00:04:34,163
+இரண்டிற்கும் இடையே <DT>pivot</DT> வருவதை உறுதிசெய்கிறோம். ஏனெனில் <DT>array</DT> ல் முதல் <DT>element</DT> <DT>pivot</DT> ஆக எடுத்துள்ளோம்.
+
+47
+00:04:34,190 --> 00:04:41,036
+இதற்குப் பிறகு நாம் அதை <DT>lower</DT> மற்றும் <DT>upper bound</DT> க்கு இடையில் உள்ள <DT>center</DT> க்கு நகர்த்த விரும்புகிறோம். பின்னர், இரண்டு <DT>partitions</DT> களை <DT>recursively sort</DT> செய்கிறோம்.
+
+48
+00:04:44,456 --> 00:04:48,910
+ஒரு பொதுவான <DT>list</DT> ல் <DT>quick sort</DT> எவ்வாறு வேலை செய்யும் என்பது பற்றிய <DT>high level view</DT> இங்கே உள்ளது.
+
+49
+00:04:48,910 --> 00:04:56,143
+இது தான் நமது  <DT>list</DT> என்று வைத்துக்கொள்வோம். <DT>list</DT> ன் தொடக்கத்தை <DT>pivot element</DT> ஆக முதல் <DT>element</DT> ஐ அடையாளம் காண்போம்.
+
+50
+00:04:56,950 --> 00:05:01,569
+இப்போது, மீதமுள்ள <DT>elements</DT> களில், எந்த <DNT>ones</DNT> <DT>smaller</DT> மற்றும் எந்த <DNT>ones</DNT> <DT>bigger</DT> என்பதைக் கண்டுபிடிக்க வேண்டும்.
+
+51
+00:05:02,410 --> 00:05:11,510
+இதை எப்படிச் செய்வோம் என்று சொல்லாமல், 32, 22 மற்றும் 13 ஆகிய மூன்று <DT>elements</DT> களை <DT>smaller</DT> ஆகவும் <DNT>yellow</DNT> ல் <DT>marked </DT> செய்யபட்டதாகவும் அடையாளப்படுத்துகிறோம்.
+
+52
+00:05:11,810 --> 00:05:15,069
+மற்றும் <DNT>green</DNT> இல் <DT>marked </DT> செய்யப்பட்ட மற்ற 4 <DT>elements</DT> கள் பெரியவை.
+
+53
+00:05:16,160 --> 00:05:20,040
+முதல் <DT>step</DT> உண்மையில் இந்த <DT>criterion</DT> ஐ பொறுத்து <DT>partition</DT> செய்ய வேண்டும்.
+
+54
+00:05:20,040 --> 00:05:24,810
+நாம் இந்த <DT>elements</DT> களை நகர்த்த வேண்டும். அதனால் அவை இரண்டு <DT>blocks</DT> ஆக வரும்.
+
+55
+00:05:24,810 --> 00:05:27,550
+அந்த 13, 32 மற்றும் 22 <DT>left</DT> பக்கம் வரும்.
+
+56
+00:05:27,550 --> 00:05:33,430
+63 57, 91 மற்றும் 78, <DNT>right</DNT> மற்றும் <DT>pivot element</DT> 43 <DT>middle</DT> ல் வருகிறது.
+
+57
+00:05:33,947 --> 00:05:36,781
+இது <DT>rearranging step</DT> மற்றும் இப்போது
+
+58
+00:05:37,060 --> 00:05:41,529
+நாம் <DNT>yellow bits</DNT> மற்றும் <DNT>green bits</DNT> ஆகியவற்றை <DT>recursively sort</DT> செய்வோம். பிறகு அதைச் செய்யலாம் என்று கருதினால்,
+
+59
+00:05:41,529 --> 00:05:45,480
+ந���்மிடம் ஒரு <DT>sorted array</DT> உள்ளது மற்றும் அனைத்து <DNT>yellow</DNT> பொருட்களும் <DT>smaller than </DT>43 ஆக இருப்பதை கவனிக்கவும்.
+
+60
+00:05:45,480 --> 00:05:49,509
+மேலும் அனைத்து <DNT>green</DNT> விஷயங்களும் <DT>bigger than</DT> 43. மேலும் <DT>merging</DT> செய்ய தேவையில்லை.
+
+61
+00:05:52,243 --> 00:05:54,899
+எனவே, <DT>partitioning</DT> எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்.
+
+62
+00:05:54,899 --> 00:05:59,350
+இங்கே நம்மிடம் முந்தைய <DT>list</DT> ல் உள்ளது. மேலும் 43 ஐ நமது <DT>pivot element</DT> ஆக <DT>marked </DT> செய்துள்ளோம்.
+
+63
+00:05:59,350 --> 00:06:03,112
+மீதமுள்ள <DT>elements</DT> களை <DT>scan</DT> செய்து அவற்றை <DT>divide</DT> செய்ய விரும்புகிறோம்.
+
+64
+00:06:03,137 --> 00:06:08,742
+இரண்டு குழுக்கள், <DT>smaller than</DT> 43, <DNT>yellow ones</DNT>, <DT>bigger than</DT> 43, <DNT>green ones</DNT> மற்றும் அவற்றை <DT>rearrange</DT> செய்யவும்.
+
+65
+00:06:09,962 --> 00:06:13,839
+நாம் என்ன செய்வோம் இரண்டு <DT>pointers</DT> கள் <DNT>yellow pointer</DNT> மற்றும் <DNT>green pointer</DNT> ஐ வைத்திருப்போம்.
+
+66
+00:06:14,155 --> 00:06:19,081
+மேலும் பொதுவான விதி என்னவென்றால், எந்த ஒரு <DT>point</DT>லும் நாம் சிறிது <DT>distance</DT> ல் இருப்போம்.
+
+67
+00:06:19,355 --> 00:06:24,129
+நான் <DNT>orange</DNT> நிறத்தில் வரையப் போகும் <DT>visible</DT> <DNT>yellow pointer</DNT> மற்றும் <DNT>green pointer</DNT>.
+
+68
+00:06:24,129 --> 00:06:29,165
+இவை இந்த <DT>order</DT> ல் நகரும் <DNT>orange pointer</DNT> அல்லது <DNT>yellow pointer</DNT> எப்போதும் <DNT>green pointer</DNT> பின்னால் இருக்கும்.
+
+69
+00:06:29,565 --> 00:06:35,397
+நீங்கள் பராமரிக்கும் <DT>inductive property</DT> என்னவென்றால், இந்த <DT>elements</DT> கள் 43 ஐ விட <DT>smaller than</DT> அல்லது சமமாகவோ இருக்கும்.
+
+70
+00:06:35,910 --> 00:06:40,643
+இந்த <DT>elements</DT> கள் <DT>bigger than</DT> 43 மற்றும் இந்த <DT>elements</DT> கள் <DT>தெரியவில்லை</DT>.
+
+71
+00:06:42,577 --> 00:06:46,139
+நாம் செய்ய முயற்சிப்பது என்னவென்றால், <DT>left</DT> ல் இருந்து <DNT>right</DNT> க்கு நகர்த்த முயற்சிக்கிறோம்.
+
+72
+00:06:46,139 --> 00:06:49,589
+ஒவ்வொரு முறையும் <DT>unknown elements</DT> ஐ காணும் அனைத்து <DT>unknown elements</DT> களையும் <DT>classify</DT> செய்யவும்.
+
+73
+00:06:49,552 --> 00:06:52,660
+இந்த property ஐ நாம் maintain பண்ண இரண்டு <DT>pointers</DT> களை மாற்றுவோம்.
+
+74
+00:06:52,700 --> 00:06:57,699
+43 க்கும் முதல் <DT>pointer</DT> க்கும் இடையில் <DT>elements smaller than</DT> 43 அல்லது அதற்கு சமமாக உள்ளன.
+
+75
+00:06:57,699 --> 00:07:01,494
+முதல் <DT>pointer</DT> க்கும் இரண்டாவது <DT>pointer</DT> க்கும் இடையில் நம் <DT>elements</DT> கள் கண்டிப்பாக 43 க்கு <DT>greater</DT> ஆக உள்ளது.
+
+76
+00:07:01,752 --> 00:07:05,230
+மற்றும் <DNT>green pointer</DNT> இன் <DNT>right</DNT> பக்கம் இன்னும் <DT>scanned</DT> செய்யப்படாதவை  உள்ளன.
+
+77
+00:07:07,023 --> 00:07:10,000
+எனவே, ஆரம்பத்தில் எதுவும் தெரியவில்லை. பின்னர் நாம் 32 ஐ பார்க்கிறோம்.
+
+78
+00:07:10,000 --> 00:07:14,618
+32 43 ஐ விட <DT>smaller than</DT> ஆக இருப்பதால், <DNT>yellow pointer</DNT> ஐ நகர்த்துகிறோம். மேலும் <DNT>green pointer</DNT> ஐ உடன் தள்ளுகிறோம்.
+
+79
+00:07:14,643 --> 00:07:16,949
+தெரியாத விஷயம் 22 இல் தொடங்குகிறது.
+
+80
+00:07:16,949 --> 00:07:22,060
+<DNT>yellow</DNT> மற்றும் <DNT>green pointer</DNT> ஆகியவற்றுக்கு இடையே எதுவும் இல்லை. <DT>value bigger than</DT> 43 ஐ நாம் இன்னும் கண்டுபிடிக்கவில்லை.
+
+81
+00:07:22,949 --> 00:07:24,910
+எனவே, 22 க்கும் அதே நடக்கும்.
+
+82
+00:07:24,910 --> 00:07:28,629
+இப்போது, 78ஐ பார்க்கும்போது, 78 <DT>bigger than</DT> 43 என்பதைக் கவனிக்கிறோம்.
+
+83
+00:07:29,008 --> 00:07:33,635
+இப்போது, நாம் <DNT>green pointer</DNT> ஐ மட்டுமே நகர்த்துகிறோம். மேலும் <DNT>yellow pointer</DNT> ஐ அல்ல. இப்போது, இந்த 3 இடைவெளிகளை முன்பு போலவே வைத்திருக்கிறோம்.
+
+84
+00:07:33,935 --> 00:07:36,819
+இது 43 க்கு குறைவான <DT>equal</DT> ஆன பகுதி என்பதை நினைவில் கொள்ளுங்கள்.
+
+85
+00:07:36,819 --> 00:07:44,350
+இது <DT>greater than</DT> 43 உள்ள பகுதி மற்றும் இந்த பகுதி unknown <DNT>right</DNT>, நாம் இந்த வழியில் தொடர்கிறோம்.
+
+86
+00:07:44,350 --> 00:07:48,189
+இப்போது நாம் 63 ஐ பார்க்கிறோம். மீண்டும் 63 <DNT>green zone</DNT> ஐ நீட்டிக்கிறது.
+
+87
+00:07:48,189 --> 00:07:52,540
+57 ஒரு <DNT>green zone</DNT> ஐ நீட்டிக்கிறது 91 ஒரு <DNT>green zone</DNT> ஐ நீட்டிக்கிறது.
+
+88
+00:07:52,540 --> 00:07:56,470
+இப்போது, 13 ஐ கண்டுபிடிக்கும்போது நாம் ஏதாவது செய்ய வேண்டும்.
+
+89
+00:07:56,470 --> 00:08:00,100
+13 என்பது இப்போது <DNT>yellow zone</DNT> ல் சேர்க்கப்பட வேண்டிய ஒரு <DT>element</DT>.
+
+90
+00:08:00,205 --> 00:08:03,705
+ஒரு <DT>strategy</DT> நிறைய மாற்றங்களைச் செய்ய வேண்டும்.
+
+91
+00:08:03,730 --> 00:08:07,360
+நாம் 13 ஐ 22 இருக்கும் இடத்திற்கு அல்லது 22 க்குப் பிறகு நகர்த்துகிறோம்.
+
+92
+00:08:07,360 --> 00:08:10,180
+மேலும் 78 இல் இருந்து எல்லாவற்றையும் <DNT>right</DNT> க்கு தள்ளுகிறோம்.
+
+93
+00:08:10,250 --> 00:08:15,220
+ஆனால் உண்மையில், ஒரு புத்திசாலித்தனமான <DT>strategy</DT> என்னவென்றால், 13 இங்கே செல்ல வேண்டும் என்று சொல்வது.
+
+94
+00:08:17,605 --> 00:08:21,519
+நாம் space ஐ உருவாக்க வேண்டும். ஆனால் <DT>space</DT> ஐ உருவாக்குவதற்கு பதிலாக.
+
+95
+00:08:21,519 --> 00:08:30,399
+எப்படியும் <DNT>green</DNT> விஷயங்களை நாம் <DT>sort</DT> செய்யபோகிறோம். அது  ஒரு பொருட்டல்ல என்று சொல்லலாம். இரண்டையும் எந்த வழியில் <DT>sort</DT> செய்கிறோம் என்பது எப்படி முக்கியம்.  இந்த 78ஐ எடுத்து 13க்கு நகர்த்துவோம்.
+
+96
+00:08:30,399 --> 00:08:33,009
+எந்த மாற்றத்தையும் செய்வதற்கு பதிலாக.
+
+97
+00:08:33,009 --> 00:08:36,370
+<DNT>green</DNT> zone ல் முதல் <DT>element</DT> ஐ <DT>exchange</DT> செய்கிறோம்.
+
+98
+00:08:36,370 --> 00:08:38,320
+நாம் இதுவரை பார்க்கும் <DT>element</DT> உடன்.
+
+99
+00:08:38,320 --> 00:08:41,980
+அது தானாகவே <DNT>yellow zone</DNT> மற்றும் <DNT>green zone</DNT> இரண்டையும் சரியாக நீட்டிக்கும்.
+
+100
+00:08:42,080 --> 00:08:49,299
+நமது அடுத்த <DT>step</DT> 13 <DT>smaller than</DT> 43 என்பதை கண்டறிந்து, அதை 73 உடன் <DT>இடமாற்று</DT> செய்வது.
+
+101
+00:08:49,399 --> 00:08:54,070
+இப்போது, நம்மிடம் உள்ள <DT>pivot</DT> ன் <DNT>right</DNT> க்கு ஒரு <DT>intermediate stage</DT> ஐ அடைந்துள்ளோம்.
+
+102
+00:08:54,070 --> 00:08:58,360
+எல்லாவற்றையும் scanned செய்து, அவற்றை <DT>smaller</DT> ஆக வகைப்படுத்தியுள்ளோம்.
+
+103
+00:08:58,360 --> 00:08:59,889
+மற்றும் <DT>bigger</DT> ஐயும்.
+
+104
+00:09:00,716 --> 00:09:04,216
+இப்போது, <DNT>yellow</DNT> விஷயங்களை 43க்கு <DT>left</DT> பக்கம் <DT>push</DT> செய்ய வேண்டும்.
+
+105
+00:09:05,036 --> 00:09:09,165
+இப்போது, <DNT>yellow zone</DNT> ல் 13ஐ சேர்த்தபோது பார்த்த அதே <DT>problem</DT> மீண்டும் ஒருமுறை நமக்கு வந்துள்ளது.
+
+106
+00:09:09,190 --> 00:09:13,210
+நாம் 43 ஐ சரியான இடத்திற்கு நகர்த்தினால், இங்கே அனைத்தையும் <DNT>left</DNT> க்கு நகர்த்த வேண்டும்.
+
+107
+00:09:13,404 --> 00:09:18,940
+ஆனால், அதற்குப் பதிலாக இந்த 13ஐ <DNT>yellow zone</DNT> ல் கடைசி <DT>element</DT> ஆக எடுத்துக்கொள்ளலாம்.
+
+108
+00:09:18,940 --> 00:09:22,149
+மற்றும் அதை அங்கே <DT>replace</DT> செய்யவும். 32 மற்றும் 22 ஐ shift செய்ய வேண்டாம்.
+
+109
+00:09:22,149 --> 00:09:26,759
+இது <DT>order</DT> ஐ சீர்குலைக்கிறது. ஆனால் எப்படியும் இது <DT>unsorted</DT> செய்யாமல், <DT>unsorted</DT> ஆக உள்ளது.
+
+110
+00:09:27,632 --> 00:09:29,889
+நாம் இதை செய்கிறோம். இப்போது நம்மிடம் உள்ளது.
+
+111
+00:09:30,001 --> 00:09:36,171
+நாம் விரும்பியபடி <DT>array rearranged</DT> செய்யப்பட்டது.  எனவே, <DT>left</DT> ல் உள்ள இவை அனைத்தும் <DT>smaller than</DT> <DT>pivot</DT>.
+
+112
+00:09:37,244 --> 00:09:41,856
+<DT>pivot</DT> நடுவில் உள்ளது.  மற்றும் <DNT>right</DNT> ல் உள்ள அனைத்தும் <DT>bigger than</DT> <DT>pivot</DT>.
+
+113
+00:09:46,550 --> 00:09:53,830
+இங்கே <DT>python</DT> இன் ஒரு <DT>implementation</DT> உள்ளது. <DT>quick sort</DT> என்பது  <DT>merge sort </DT> மற்றும் <DT>binary research</DT> போன்றவற்றைக் கொண்டிருக்கும் என்பதை நினைவில் கொள்ளவும்.
+
+114
+00:09:53,830 --> 00:09:58,690
+<DT>smaller</DT> மற்றும் <DT>smaller segments</DT> ல் அதை மீண்டும் மீண்டும் பயன்படுத்துகிறோம். பொதுவாக நாம் அதை <DT>pass</DT> செய்யவும்.
+
+115
+00:09:58,690 --> 00:10:03,523
+நாம் <DNT>call A</DNT> என்ற <DT>list</DT> க்கும், <DT>segment</DT> ன் <DT>end points</DT> ஆன <DNT>left</DNT> மற்றும் <DNT>right</DNT>.
+
+116
+00:10:03,548 --> 00:10:07,238
+நாம் ஒரு <DNT>slice l </DNT> முதல் <DNT>r minus 1</DNT> வரை செய்கிறோம்.
+
+117
+00:10:08,244 --> 00:10:13,210
+இந்த <DT>slice</DT> 1 அல்லது 0 <DT>length</DT> ஆக இருந்தால், நாம் எதுவும் செய்ய மாட்டோம்.
+
+118
+00:10:14,223 --> 00:10:17,320
+இல்லையெனில், நாம் முன்பு இருந்த இந்த <DT>partitioning strategy</DT> ஐ பின்பற்றுவோம்.
+
+119
+00:10:17,708 --> 00:10:22,120
+அதாவது <DNT>l</DNT> இலிருந்து <DNT>r minus 1</DNT> வரை <DT>sorting</DT> செய்கிறோம்.
+
+120
+00:10:22,120 --> 00:10:24,220
+எனவே, <DT>position l</DT>.
+
+121
+00:10:24,379 --> 00:10:25,899
+இது <DT>pivot</DT> ஆகும்.
+
+122
+00:10:26,793 --> 00:10:29,671
+<DNT>right</DNT> முதலில் இங்கே <DNT>yellow pointer</DNT> ஐ வைப்போம்.
+
+123
+00:10:31,011 --> 00:10:33,635
+<DNT>yellow zone</DNT> இன் முடிவு என்று கூறுகிறது.
+
+124
+00:10:34,005 --> 00:10:38,500
+உண்மையில் <DT>pivot</DT> உள்ளது அங்கு எதுவும் இல்லை. <DNT>yellow</DNT> என்பது <DNT>l plus 1</DNT> ஆகும்.
+
+125
+00:10:38,500 --> 00:10:50,781
+இப்போது <DNT>green</DNT>ஐ தொடர அனுமதிக்கிறோம். ஒவ்வொரு <DT>time</DT>ம் <DNT>green</DNT> இல் ஒரு <DT>element</DT> ஐ பார்க்கும்போது புதிய <DNT>green</DNT> ஒன்���ைக் காட்டிலும் <DT>smaller than</DT> ஆக இருக்கும் <DT>pivot</DT> ஆகும். இது <DT>pivot</DT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+126
+00:10:51,965 --> 00:10:55,661
+<DNT>right</DNT> நாம் எப்போதாவது ஒரு <DNT>green</DNT> ஐ பார்த்தால், அடுத்த <DT>value</DT> ஐ.
+
+127
+00:10:55,686 --> 00:10:57,580
+சரிபார்க்கப்பட வேண்டியதை விட <DT>smaller than</DT> அல்லது சமமானது.
+
+128
+00:10:57,590 --> 00:11:01,714
+நாம் <DT>exchange</DT> செய்கிறோம். இதனால் இந்த <DT>value</DT> ஐ <DNT>yellow zone</DNT> ன் முடிவுக்குக் கொண்டு வருகிறோம்.
+
+129
+00:11:01,739 --> 00:11:03,220
+இதைத்தான் 13ல் செய்தோம்.
+
+130
+00:11:03,344 --> 00:11:07,590
+பின்னர், <DNT>yellow pointer</DNT> ஐ நகர்த்துகிறோம். இல்லையெனில் கண்டிப்பாக <DT>bigger</DT> <DT>value</DT> ஐ கண்டால் நகர்த்துவோம்.
+
+131
+00:11:07,590 --> 00:11:11,860
+<DNT>green pointer</DNT> மட்டுமே <DT>for loop</DT> ஆல் மறைமுகமாக செய்யப்படுகிறது. மற்றொன்றை நகர்த்த மாட்டோம்.
+
+132
+00:11:11,929 --> 00:11:14,883
+இதன் முடிவில் நமக்கு <DT>pivot</DT> உள்ளது.
+
+133
+00:11:15,894 --> 00:11:19,784
+நாம் <DT>pivot</DT> க்கு சமமானதைக் காட்டிலும் குறைவானதைக் கொண்டுள்ளோம். பின்னர் <DT>greater than pivot</DT> ம் கொண்டுள்ளோம்.
+
+134
+00:11:19,809 --> 00:11:27,914
+இந்த விதியின் முடிவில் நாம் அடைந்த அந்த intermediate stage இதுதான். இப்போது, நாம் <DT>pivot</DT> ஐ கண்டுபிடித்து சரியான இடத்திற்கு நகர்த்த வேண்டும். எனவே, <DNT>yellow</DNT> என்பதை நினைவில் கொள்ளுங்கள்.
+
+135
+00:11:29,241 --> 00:11:32,769
+<DNT>yellow</DNT> <DNT>last</DNT> க்கு அப்பால் உள்ள <DT>position</DT> ஐ சுட்டிக்காட்டுகிறது.
+
+136
+00:11:32,769 --> 00:11:37,440
+<DT>element அதை விட சிறியது</DT>. <DNT>yellow</DNT> இதற்கு முன் எப்போதும் ஒரு <DT>value</DT> ஆகும்.
+
+137
+00:11:37,440 --> 00:11:40,396
+<DNT>yellow</DNT> minus 1 இன் <DT>value</DT> ஐ எடுத்து, <DT>left value</DT> உடன் <DT>exchange</DT> செய்வோம்.
+
+138
+00:11:41,414 --> 00:11:48,765
+இப்போது நாம் செய்ய வேண்டியது என்னவென்றால், நம்மிடம் இப்போது <DNT> p, p and greater than p</DNT> ஐ விட குறைவாக உள்ளது.
+
+139
+00:11:49,627 --> 00:12:01,350
+இங்குதான் <DNT>yellow</DNT> <DNT>சரியானது</DNT>. நாம் 0 இலிருந்து <DNT>yellow</DNT> minus 1 க்கு செல்ல வேண்டும். மீண்டும் <DNT>sort p </DNT> ஐ விரும்பவில்லை. ஏனெனில் <DNT>p</DNT> ஏற்கனவே சரியான இடத்தில் வைக்கப்பட்டுள்ளது.
+
+140
+00:12:01,350 --> 00:12:06,391
+<DNT>L</DNT> இலிருந்து <DNT>yellow</DNT> minus 1 ஆகவும், <DNT>yellow</DNT> இலிருந்து <DNT>right</DNT> முனையிலும் <DT>quick sort</DT> செய்வோம்.
+
+141
+00:12:13,070 --> 00:12:17,070
+<DT>slide</DT> ல் பார்த்த <DT>python code</DT> ஐ இங்கே ஒரு <DT>file</DT> ல் எழுதியுள்ளோம்.
+
+142
+00:12:17,070 --> 00:12:20,320
+slide ல் இருந்த அதே <DT>code</DT> இதுதானா என்பதை சரிபார்க்கலாம்.
+
+143
+00:12:20,345 --> 00:12:28,786
+நாம் அதை முயற்சி செய்து <DT>run</DT> செய்யலாம் மற்றும் அது செயல்படுகிறதா என்று சரிபார்க்கலாம். <DT>call python</DT>, இந்த <DT>function</DT> ஐ <DT>import</DT> செய்கிறோம்.
+
+144
+00:12:32,849 --> 00:12:37,699
+இது மீண்டும் ஒரு வகையான <DT>sorts</DT> <DT>function</DT> என்பதை நினைவில் கொள்ளுங்கள். எதையாவது <DT>sort</DT> செய்து அதன் விளைவைப் பார்க்க விரும்பினால்.
+
+145
+00:12:37,753 --> 00:12:40,870
+நாம் அதற்கு ஒரு <DT>name</DT> ஐ <DT>assign</DT> செய்ய வேண்டும். பின்னர் அந்த <DT>name</DT> ஐ <DT>sort</DT> செய்து, பிறகு <DT>name</DT> ஐ சரிபார்க்க வேண்டும்.
+
+146
+00:12:40,909 --> 00:12:48,137
+எடுத்துக்காட்டாக, 500 முதல் 0 வரையிலான <DT>range</DT> of <DT>values</DT> ஐ எடுத்துக் கொள்வோம்.
+
+147
+00:12:50,287 --> 00:12:58,090
+இப்போது நாம் <DNT>quicksort l</DNT> என்று சொன்னால், அதற்கு <DNT>of course</DNT> முடிவைக் கொடுக்க வேண்டும்.
+
+148
+00:13:01,020 --> 00:13:02,468
+பிறகு <DNT>l</DNT> சரியாக <DT>sorted</DT> செய்யப்படும்.
+
+149
+00:13:04,311 --> 00:13:09,523
+நீங்கள் அனைத்தையும் பார்க்க முடியாது. ஆனால்  83 84 முதல் நூறு வரை மற்றும் இரண்டு 500 வரை பார்க்க முடியும்.
+
+150
+00:13:10,995 --> 00:13:16,480
+இப்போது, 1000 என்று சொன்னால், <DT>insertion sort</DT> ல் நமக்கு இருந்த அதே <DT>problem</DT> உள்ளது.
+
+151
+00:13:17,897 --> 00:13:22,596
+பின்னர் நாம் இதை <DT>quicksort</DT> செய்ய முயற்சிக்கிறோம். நீங்கள் இதை <DT>recursion depth</DT> ஆல் பெறுவீர்கள்.
+
+152
+00:13:22,621 --> 00:13:29,644
+<DT>worst case</DT> ல் நாம் பார்ப்பது போல, <DT>quick sort</DT> ஆனது <DT>insertion sort</DT> ஐ போலவே செயல்படுகிறது மற்றும் இது மோசமான case.
+
+153
+00:13:29,669 --> 00:13:33,759
+இதைப் போக்க, நாம் வழக்கமான காரியத்தைச் செய்ய வேண்டும். <DT>SYS module</DT> ஐ <DT>import</DT> செய்ய வேண்டும்.
+
+154
+00:13:33,759 --> 00:13:35,409
+<DT>recursion limit</DT> ஐ <DT>set</DT> செய்யவும்.
+
+155
+00:13:36,658 --> 00:13:43,652
+எனவே, பொருத்தமான பெரிய ஒன்று பத்தாயிரம் அல்லது நூறாயிரம் என்று சொல்லுங்கள். பின்னர் அதை <DT>quicksort</DT> செய்ய சொன்னால் எந்த problem உம்  இல்லை.
+
+156
+00:13:44,779 --> 00:13:49,299
+<DT>python</DT> ல் இந்த <DT>recursion limit</DT> ஐ manually set செய்ய வேண்டிய மற்றொரு case இதுவாகும்.
+
+157
+00:13:49,647 --> 00:13:56,929
+உண்மையில் நாம் பார்க்கக்கூடிய ஒரு விஷயம் என்னவென்றால், <DT>quicksort</DT> என்பது நாம் நம்புவது போல் நல்லதல்ல, ஏனெனில்.
+
+158
+00:13:57,008 --> 00:14:02,080
+எடுத்துக்காட்டாக, 7500 என்று ஏதாவது <DT>size</DT> ஐ <DT>instance sort</DT> செய்யவும்.
+
+159
+00:14:05,504 --> 00:14:09,554
+பின்னர் அது ஒரு புலப்படும் நேரம் எடுக்கும். எனவே, <DNT>n log n</DNT> என்று <DT>merge sort </DT> ஐ பார்த்தோம்.
+
+160
+00:14:09,790 --> 00:14:13,700
+5,000 மற்றும் 10000 மற்றும் 100,000 கூட <DT>instantaneously</DT> செய்யும்.
+
+161
+00:14:13,832 --> 00:14:18,129
+தெளிவாக <DT>quick sort</DT> மற்றும் <DT>merge sort </DT> செயல்படாது.
+
+162
+00:14:18,165 --> 00:14:22,480
+மற்றும் உண்மையில் <DT>quick sort</DT> க்கு <DT>order</DT> <DNT>n log n</DNT> <DT>merge sort </DT> இல்லை என்பதை நாம் பார்ப்போம்.
+
+163
+00:14:22,511 --> 00:14:25,090
+நாம் விரும்பியபடி நடத்தை.
+
+164
+00:14:25,090 --> 00:14:28,539
+அதற்குக் காரணம், நாம் <DT>median</DT> ஐ பயன்படுத்தாமல், split செய்வதற்கான முதல் <DT>value</DT> ஐ பயன்படுத்துகிறோம்.
+
+165
+00:14:28,539 --> 00:14:33,909
+அதை அடுத்த lecture ல் பார்ப்போம்.  ஏன் <DT>quick sort</DT> ல் உண்மையி���் ஒரு worst case <DNT>order n log n algorithm</DNT> அல்ல.
+

lip_sync_online_v1_original.py

@@ -0,0 +1,157 @@
+"""
+Lip syncing code - Online version
+"""
+
+import os
+import sys
+import moviepy.editor as mp
+from pysrt import SubRipFile, SubRipTime, SubRipItem
+import argparse
+
+
+def srt_time_to_seconds(time_datetime_format):
+    time_iso_format = time_datetime_format.isoformat()
+    # print(time_iso_format)
+    seconds = float(time_iso_format.split(':')[-1])
+    rest_list = time_iso_format.split(':')[:-1]
+    # print(rest_list)
+    if ":".join(rest_list) == "00:00":
+        pass
+    else:
+        for i in range(0,len(rest_list)):
+            if i == 0:
+                # print(rest_list[i])
+                seconds += int(rest_list[i])*3600
+            elif i == 1:
+                # print(rest_list[i])
+                seconds += int(rest_list[i])*60
+            else:
+                sys.exit("Error in time conversion")
+    return seconds
+
+def lip_sync(video_path, srt_path, audio_list, output_video, output_srt):
+
+    # output video filename without extension
+    output_filename = os.path.splitext(output_video)[0]
+
+    # read the original video as obj
+    video_obj = mp.VideoFileClip(video_path)
+
+    # read target srt file
+    srt = SubRipFile.open(srt_path)
+
+    # initialize variables
+    video_clips = []
+
+    prev_end_time = SubRipTime(0)
+
+    new_srt_start_time = []
+    new_srt_end_time = []
+    new_srt_total_duration = 0.0
+
+    # iterate through srt entries
+    for i, srt_entry in enumerate(srt):
+        
+        print(f"srt_num: {i+1}")
+
+        start_time = srt_entry.start.to_time()
+        end_time = srt_entry.end.to_time()
+
+        if srt_time_to_seconds(start_time) > srt_time_to_seconds(prev_end_time.to_time()):
+            # add inter-srt clip to video_clips
+            inter_srt_clip = video_obj.subclip(srt_time_to_seconds(prev_end_time.to_time()), srt_time_to_seconds(start_time))
+            inter_srt_clip_without_audio = inter_srt_clip.without_audio()
+            # Create a silent audio clip with the same duration as the video
+            silence = mp.afx.audio_loop(mp.AudioFileClip("silence.wav"), duration=(srt_time_to_seconds(start_time) - srt_time_to_seconds(prev_end_time.to_time())), nloops=1)
+            # Set the silent audio track in the video clip
+            inter_srt_clip_with_silence = inter_srt_clip_without_audio.set_audio(silence)
+            video_clips.append(inter_srt_clip_with_silence)
+
+            new_srt_total_duration += inter_srt_clip_with_silence.duration
+
+        srt_clip = video_obj.subclip(srt_time_to_seconds(start_time), srt_time_to_seconds(end_time))
+        srt_clip_without_audio = srt_clip.without_audio()
+        video_clips.append(srt_clip_without_audio)
+      
+        # read audio file
+        audio_clip = mp.AudioFileClip(audio_list[i])
+        
+        # interpolate video to match audio duration
+        if srt_clip.duration != audio_clip.duration:
+            
+            srt_clip = srt_clip.fx(mp.vfx.speedx, factor=srt_clip.duration/audio_clip.duration)
+          
+            srt_clip_without_audio = srt_clip.without_audio()
+
+        # replace audio in video clip
+        video_clip = srt_clip.set_audio(audio_clip)
+
+        new_srt_start_time.append(new_srt_total_duration)
+        new_srt_end_time.append(new_srt_total_duration+video_clip.duration)
+
+        new_srt_total_duration += video_clip.duration
+
+        # add video clip to list
+        video_clips[-1] = video_clip
+
+        # update previous end time
+        prev_end_time = srt_entry.end
+
+
+    # check if last srt ends before video ends and add final clip if necessary
+    last_srt_end_time = srt[-1].end.to_time()
+    video_duration = video_obj.duration
+    
+    print("Completed for loop")
+    try:
+        if last_srt_end_time != video_duration:
+            final_clip = video_obj.subclip(srt_time_to_seconds(last_srt_end_time), video_duration)
+            final_clip_without_audio = final_clip.without_audio()
+            # Create a silent audio clip with the same duration as the video
+            silence = mp.afx.audio_loop(mp.AudioFileClip("silence.wav"), duration=(video_duration - srt_time_to_seconds(last_srt_end_time)), nloops=1)
+            final_clip_with_silence = final_clip_without_audio.set_audio(silence)
+            video_clips.append(final_clip_with_silence)
+            # video_clips.append(final_clip_without_audio)
+    except:
+        print("Except")
+    
+    print("try , except completed here. check here error is there or not")
+    # concatenate video clips and write final video
+    final_video = mp.concatenate_videoclips(video_clips)
+    # final_video.write_videofile("output_video.mp4", threads=30)
+    final_video.write_videofile(output_video,  codec="libx264", threads=30, audio_codec='aac', temp_audiofile=output_filename+'.m4a', remove_temp=True, preset="medium", ffmpeg_params=["-profile:v","baseline", "-level","3.0","-pix_fmt", "yuv420p"])
+
+    # create new srt file with updated timings
+    new_srt = SubRipFile()
+    for i, srt_entry in enumerate(srt):
+        new_start_time = SubRipTime(seconds=new_srt_start_time[i])
+        new_end_time = SubRipTime(seconds=new_srt_end_time[i])
+        new_srt.append(SubRipItem(index=i+1, start=new_start_time, end=new_end_time, text=srt_entry.text))
+
+    # Write the updated srt file to file
+    new_srt.save(output_srt, encoding='utf-8')
+    
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="Lip syncing script with command-line arguments.")
+    parser.add_argument("--original_video_path", required=True, help="Path to the original video file.")
+    parser.add_argument("--Translated_SRT", required=True, help="Path to the translated SRT file.")
+    parser.add_argument("--audio_dir", required=True, help="Path to the directory containing TTS audio files.")
+    parser.add_argument("--output_video_path", required=True, help="Path for the output video file.")
+    parser.add_argument("--new_srt_path", required=True, help="Path for the output SRT file.")
+
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = parse_arguments()
+
+    video_path = args.original_video_path
+    srt_path = args.Translated_SRT
+    audio_dir = args.audio_dir
+    output_video = args.output_video_path
+    output_srt = args.new_srt_path
+
+    audio_list = os.listdir(audio_dir)
+    audio_list.sort()
+    audio_list = [os.path.join(audio_dir, file) for file in audio_list]
+
+    lip_sync(video_path, srt_path, audio_list, output_video, output_srt)

lip_sync_online_v1_silence_remove.py

@@ -0,0 +1,173 @@
+"""
+Lip syncing code - Online version
+"""
+
+import os
+import sys
+import moviepy.editor as mp
+from pysrt import SubRipFile, SubRipTime, SubRipItem
+import argparse
+
+
+def srt_time_to_seconds(time_datetime_format):
+    time_iso_format = time_datetime_format.isoformat()
+    # print(time_iso_format)
+    seconds = float(time_iso_format.split(':')[-1])
+    rest_list = time_iso_format.split(':')[:-1]
+    # print(rest_list)
+    if ":".join(rest_list) == "00:00":
+        pass
+    else:
+        for i in range(0,len(rest_list)):
+            if i == 0:
+                # print(rest_list[i])
+                seconds += int(rest_list[i])*3600
+            elif i == 1:
+                # print(rest_list[i])
+                seconds += int(rest_list[i])*60
+            else:
+                sys.exit("Error in time conversion")
+    return seconds
+
+def lip_sync(video_path, srt_path, audio_list, output_video, output_srt):
+    print("length of audui list:", len(audio_list))
+    # output video filename without extension
+    output_filename = os.path.splitext(output_video)[0]
+
+    # read the original video as obj
+    video_obj = mp.VideoFileClip(video_path)
+    
+    # read target srt file
+    srt = SubRipFile.open(srt_path)
+
+    # initialize variables
+    video_clips = []
+
+    prev_end_time = SubRipTime(0)
+
+    new_srt_start_time = []
+    new_srt_end_time = []
+    new_srt_total_duration = 0.0
+    sil_total_dur = 0
+    sil_total_dur_effective = 0
+    aud_total_dur = 0
+
+    # iterate through srt entries
+    for i, srt_entry in enumerate(srt):
+        
+        print(f"srt_num: {i+1}")
+
+        start_time = srt_entry.start.to_time()
+        end_time = srt_entry.end.to_time()
+
+        if srt_time_to_seconds(start_time) > srt_time_to_seconds(prev_end_time.to_time()):
+           
+            # Create a silent audio clip with the same duration as the video
+            sil_dur = srt_time_to_seconds(start_time) - srt_time_to_seconds(prev_end_time.to_time())
+            sil_total_dur += sil_dur
+            sil_dur = sil_dur * 0.9194003385185787
+            sil_total_dur_effective += sil_dur
+            
+            silence = mp.afx.audio_loop(mp.AudioFileClip("silence.wav"), duration=(sil_dur), nloops=1)
+            # Set the silent audio track in the video clip
+            
+            # add inter-srt clip to video_clips
+            inter_srt_clip = video_obj.subclip(srt_time_to_seconds(prev_end_time.to_time()), srt_time_to_seconds(start_time))
+            inter_srt_clip = inter_srt_clip.fx(mp.vfx.speedx, factor=inter_srt_clip.duration/sil_dur)
+            inter_srt_clip_without_audio = inter_srt_clip.without_audio()
+            
+            inter_srt_clip_with_silence = inter_srt_clip_without_audio.set_audio(silence)
+            video_clips.append(inter_srt_clip_with_silence)
+
+            new_srt_total_duration += inter_srt_clip_with_silence.duration
+
+        srt_clip = video_obj.subclip(srt_time_to_seconds(start_time), srt_time_to_seconds(end_time))
+        srt_clip_without_audio = srt_clip.without_audio()
+        video_clips.append(srt_clip_without_audio)
+
+        # print("i:",i)
+        # read audio file
+        audio_clip = mp.AudioFileClip(audio_list[i])
+        aud_total_dur+=audio_clip.duration
+        # interpolate video to match audio duration
+        if srt_clip.duration != audio_clip.duration:
+            
+            srt_clip = srt_clip.fx(mp.vfx.speedx, factor=srt_clip.duration/audio_clip.duration)
+          
+            srt_clip_without_audio = srt_clip.without_audio()
+
+        # replace audio in video clip
+        video_clip = srt_clip.set_audio(audio_clip)
+
+        new_srt_start_time.append(new_srt_total_duration)
+        new_srt_end_time.append(new_srt_total_duration+video_clip.duration)
+
+        new_srt_total_duration += video_clip.duration
+
+        # add video clip to list
+        video_clips[-1] = video_clip
+
+        # update previous end time
+        prev_end_time = srt_entry.end
+
+    print("silence total duration",sil_total_dur)
+    print("silence total duration effective",sil_total_dur_effective)
+    print("new_srt_total_duration",new_srt_total_duration)
+    print("aud_total_dur",aud_total_dur)
+
+    # check if last srt ends before video ends and add final clip if necessary
+    last_srt_end_time = srt[-1].end.to_time()
+    video_duration = video_obj.duration
+    print("Completed for loop")
+        
+    try:
+        if last_srt_end_time != video_duration:
+            final_clip = video_obj.subclip(srt_time_to_seconds(last_srt_end_time), video_duration)
+            final_clip_without_audio = final_clip.without_audio()
+            # Create a silent audio clip with the same duration as the video
+            silence = mp.afx.audio_loop(mp.AudioFileClip("silence.wav"), duration=(video_duration - srt_time_to_seconds(last_srt_end_time)), nloops=1)
+            final_clip_with_silence = final_clip_without_audio.set_audio(silence)
+            video_clips.append(final_clip_with_silence)
+            # video_clips.append(final_clip_without_audio)
+    except:
+        print("Except")
+    print("try , except function completed here")
+    # concatenate video clips and write final video
+    final_video = mp.concatenate_videoclips(video_clips)
+    # final_video.write_videofile("output_video.mp4", threads=30)
+    final_video.write_videofile(output_video,  codec="libx264", threads=30, audio_codec='aac', temp_audiofile=output_filename+'.m4a', remove_temp=True, preset="medium", ffmpeg_params=["-profile:v","baseline", "-level","3.0","-pix_fmt", "yuv420p"])
+
+    # create new srt file with updated timings
+    new_srt = SubRipFile()
+    for i, srt_entry in enumerate(srt):
+        new_start_time = SubRipTime(seconds=new_srt_start_time[i])
+        new_end_time = SubRipTime(seconds=new_srt_end_time[i])
+        new_srt.append(SubRipItem(index=i+1, start=new_start_time, end=new_end_time, text=srt_entry.text))
+
+    # Write the updated srt file to file
+    new_srt.save(output_srt, encoding='utf-8')
+    
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="Lip syncing script with command-line arguments.")
+    parser.add_argument("--original_video_path", required=True, help="Path to the original video file.")
+    parser.add_argument("--Translated_SRT", required=True, help="Path to the translated SRT file.")
+    parser.add_argument("--audio_dir", required=True, help="Path to the directory containing TTS audio files.")
+    parser.add_argument("--new_video", required=True, help="Path for the output video file.")
+    parser.add_argument("--new_srt", required=True, help="Path for the output SRT file.")
+
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = parse_arguments()
+
+    video_path = args.original_video_path
+    srt_path = args.Translated_SRT
+    audio_dir = args.audio_dir
+    output_video = args.new_video
+    output_srt = args.new_srt
+
+    audio_list = os.listdir(audio_dir)
+    audio_list.sort()
+    audio_list = [os.path.join(audio_dir, file) for file in audio_list]
+    print("srt_path:", srt_path)
+    lip_sync(video_path, srt_path, audio_list, output_video, output_srt)

requirements.txt

@@ -0,0 +1,4 @@
+moviepy==1.0.3
+pysrt==1.1.2
+Requests==2.31.0
+webvtt_py==0.4.6

run_script.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+# Get the directory of the Bash script
+script_dir="$(dirname "$(realpath "$0")")"
+
+# Set the path to your virtual environment
+# virtual_env_path="../envs/cnn_envs/bin/activate"
+
+# Set your paths and language here (relative to the script's location)
+
+# Target language {'hin':'hindi','mal':'malayalam','kan':'kannada','bn':'bengali','ur':'urdu','tel':'telugu','pun':'punjabi', 'mar':'marathi', 'guj':'gujarati', 'tam':'tamil', 'hin':'hindi','en':'english'}
+
+target_lang="tam"
+
+# Original video path 
+original_video_path="$script_dir/OrigVideo/Week4_Lecture3.mp4"
+
+# Translated SRT path
+translated_srt_path="$script_dir/Translated_SRT/Week4_Lecture3_Cleaned_Tagged.ta.srt"
+
+
+output_audio_segments_path="$script_dir/TTS_AUDIO"
+final_output_file_path="$script_dir/final_output_vedios"
+
+srt_folderpath="$script_dir/Translated_SRT"
+
+# Activate the virtual environment
+# source "$virtual_env_path"
+
+
+# Extract the original video filename without extension
+original_video_name=$(basename "$original_video_path" .mp4)
+srt_file_name=$(basename "$translated_srt_path" .srt)
+# Automatically create new video and SRT file paths based on the original video name
+new_video="$script_dir/$original_video_name.mp4"
+new_srt="$script_dir/$original_video_name.srt"
+
+# Create a folder for each target language if it doesn't exist
+output_folder="$final_output_file_path/$target_lang"
+if [ ! -d "$output_folder" ]; then
+    mkdir -p "$output_folder"
+fi
+
+#echo "location1"
+# Call the Python script for SRT to audio conversion
+python3 "$script_dir/srt_to_audio_original.py" --target_lang "$target_lang" --output_audiopath "$output_audio_segments_path" --srt_folderpath "$srt_folderpath"
+
+# TTS audio directory
+audio_dir="$output_audio_segments_path/${target_lang}_WAV/$srt_file_name"
+
+echo "audio_dir"
+
+#echo "location2"
+# Call the Python lip syncing script with the provided arguments
+python3 "$script_dir/lip_sync_online_v1_original.py" --original_video_path "$original_video_path" --Translated_SRT "$translated_srt_path" --audio_dir "$audio_dir" --output_video_path "$new_video" --new_srt_path "$new_srt"
+
+#echo "location3"
+# Run ffmpeg command to convert SRT to ASS to add Subtitle to New Video 
+ffmpeg -i "$new_srt" -vf "ass=fontsize=12" "$script_dir/$original_video_name.ass"
+
+ffmpeg -i "$new_video" -vf "ass=$script_dir/$original_video_name.ass" "$output_folder/$original_video_name"_with_subtitle.mp4
+
+# Remove temporary files
+rm "$new_srt" "$new_video" "$script_dir/$original_video_name.ass"

srt_to_audio_original.py

@@ -0,0 +1,49 @@
+'''
+Machine Translation to Lipsync
+Created by: Abdullah Mazhar
+Date: 20/02/2023
+'''
+
+import os
+import requests
+import json
+import argparse
+from text_to_vtt import SrtToWebVttConverter
+from vtt_to_speech import TextToSpeechAPI
+import shutil
+
+class Translator:
+    def __init__(self, target_lang, output_audiopath, srt_folderpath):
+        self.tts_url = "http://127.0.0.0:3001/vtt_to_speech" #your TTS API URL
+        self.output_audiopath = output_audiopath
+        self.srt_folderpath = srt_folderpath
+        self.target_lang = target_lang
+
+    ##This is the main function that is calling other functionslike (MT, TXT to SRT, SRT to VTT and VTT to Audio)
+    def main(self):
+        for srt_file in os.listdir(self.srt_folderpath):
+            if srt_file != ".DS_Store":
+                srt_filename = srt_file.split(".srt")[0]
+                srt_filepath = os.path.join(self.srt_folderpath,srt_file)
+                print(srt_filepath)
+                tsv = SrtToWebVttConverter(srt_filename, self.output_audiopath)
+                # print('1:',tsv)
+                print("srt_filrpath:",srt_filepath)
+                vtt_filepath, vtt_folderpath= tsv.convert_srt_to_webvtt(srt_filepath)
+                print("vtt_filepath, vtt_folderpath",vtt_filepath, vtt_folderpath)
+                try:
+                    tts = TextToSpeechAPI(self.tts_url, self.output_audiopath, srt_filename, self.target_lang, vtt_filepath)
+                    tts.text_to_speech()
+                except:
+                    print("tts audio was not generated:", srt_filename)
+                # shutil.rmtree(vtt_folderpath)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Translate text files using OneMT API')
+    parser.add_argument('--target_lang', type=str, required=True, help='Target language of the input files')
+    parser.add_argument('--output_audiopath', type=str, required=True, help='Path to the directory containing input text files')
+    parser.add_argument('--srt_folderpath', type=str, required=True, help='Path to the directory to take srt files')
+    args = parser.parse_args()
+    print("srt_2_audio:",args.output_audiopath,args.srt_folderpath)
+    translator = Translator(args.target_lang, args.output_audiopath, args.srt_folderpath)
+    translator.main()

text_to_vtt.py

@@ -0,0 +1,21 @@
+import sys
+from pysrt import SubRipFile, SubRipTime, SubRipItem
+import webvtt
+import os 
+
+class SrtToWebVttConverter:
+    
+    def __init__(self, srt_filename, input_path):
+        self.srt_filename = srt_filename
+        self.input_path = input_path
+
+    def convert_srt_to_webvtt(self, srt_filepath):
+        vtt_folderpath = self.input_path + "/VTT"
+        if not os.path.exists(vtt_folderpath):
+            os.makedirs(vtt_folderpath)
+        vtt_filepath = vtt_folderpath  + "/" + self.srt_filename.split(".srt")[0] + ".vtt"
+        subtitles = webvtt.from_srt(srt_filepath)
+        subtitles.save(vtt_filepath)
+        return vtt_filepath, vtt_folderpath
+      
+

vtt_to_speech.py

@@ -0,0 +1,51 @@
+import requests
+import json
+import base64
+import os 
+
+class TextToSpeechAPI:
+    def __init__(self, tts_url, input_path, srt_filename, target_lang, vtt_filepath):
+        self.tts_url = tts_url
+        self.input_path = input_path
+        self.srt_filename = srt_filename
+        self.target_lang = target_lang
+        self.vtt_filepath= vtt_filepath
+        self.lang_dict = {'hin':'hindi','mal':'malayalam','kan':'kannada','bn':'bengali','ur':'urdu','tel':'telugu','pun':'punjabi', 'mar':'marathi', 'guj':'gujarati', 'tam':'tamil', 'hin':'hindi','en':'english'}
+
+    def text_to_speech(self, alpha=1, gender='male', segmentwise=True):#alpha=0.8333332836627969
+
+        with open(self.vtt_filepath, "r") as f:
+            text = f.read()
+        payload = json.dumps({
+            "input": text,
+            "lang": self.lang_dict[self.target_lang],
+            "gender": gender,
+            "alpha": alpha,
+            "segmentwise": segmentwise
+        })
+        headers = {
+            'Content-Type': 'application/json'
+        }
+
+        response = requests.request("GET", self.tts_url, headers=headers, data=payload)
+        print(response)
+        api_output = response.json()
+        if api_output["status"]=='success':
+            segments = api_output['segments']
+            print("length of segments:", len(segments))
+            wav_folderpath = self.input_path + "/" + self.target_lang + "_WAV"
+            if not os.path.exists(wav_folderpath):
+                    os.makedirs(wav_folderpath)
+            for wave_idx, segment in enumerate(segments):
+                file_prefix = self.srt_filename.split(".srt")[0]
+                week_folderpath = wav_folderpath + "/" + file_prefix
+                if not os.path.exists(week_folderpath):
+                    os.makedirs(week_folderpath)
+                wav_file = open("{}/{}_{:04}.wav".format(week_folderpath,file_prefix,wave_idx+1),'wb')
+                decode_string = base64.b64decode(segment)
+                wav_file.write(decode_string)
+                wav_file.close()
+
+            print(f'Log: TTS saved to folder: "{wav_folderpath}"')
+        else:
+             print(api_output['reason'])