Upload 4 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

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> அல்ல.
+