The following report presents the solver written in Matlab (Code in the Appendix) for incompressible Euler equations and results obtained on solving them for a bump geometry with a given free stream conditions. Results include contour, mesh plots of flow variables, velocity vector plots, convergence histories etc.

# Author Archives: Teja R D

# How to create your own subtitles?

Have you ever wondered how people write subtitles/captions to movies? The other day I was watching a pretty new movie(obviously pirated print) and unfortunately I couldn’t find subtitles anywhere on internet, so I thought, how about I write one and upload in internet. After few minutes of browsing I realized that they are pretty easy to make, all you need is patience to listen every word carefully and of course you should be quick enough to type what you listen. I have neither of the above qualities and got exhausted just after 20 minutes through the movie :-), so I had to quit. Here I am, writing a step-by-step guide to create subtitles for any videos or audios.

If you are using windows, you will need a text editor( I used notepad) and a software called **DivXLand Media Subtitler** which you can download here.

**Step 1: Writing what is said **

Open video or audio for which you want to create subtitles in your favourite player( you will have to rewind, pause multiple times). Simultaneously open a new text document in notepad and start writing what is said line-by-line as shown in the image (Only one line appears on the screen at any moment). If you want to split a caption into two lines, inset a ‘|’ character(without quotes) in the position where the line should be split. When you’re done writing all spoken words, save this as a plain text document (Other formats might not be ideal for the subtitler software).

**2. Synchronizing the text file**

Here we will synchronize our text file with the audio. Go to **‘file -> open text or subtitle..’, **open the above text file. Open you video by **‘file -> open video file..’** . Hit the play button and let the video play, and when the selected text is about to spoken, in default mode press and hold the **Apply** button until the line is spoken completely. The next line will be automatically selected for sync. Various other modes are available, you can read about them here.

# Selection Problem and its solution in ‘C’

We define selection problem as follows:

**Input : **An array of** N** distinct numbers and an integer **i,** with **1 ≤ i ≤ N. **

**Output : **The element that is larger than exactly** i – 1** other elements of the array.

You will obviously think of sorting the array and then simply finding the **i**th element in it, which can be done with *O(N log N) *time complexity* *using merge sort or quicksort or heapsort. But, can we do better than this? Yes, following randomized algorithm achieves this in *O(N) *expected running time practically.

This algorithm SELECT is modeled after the quicksort algorithm. As in quciksort, we partition the input array recursively. But unlike quicksort, which processes both sub-arrays, SELECT works on only one of these sub-arrays. This difference shows up in the analysis: whereas quicksort has an expected running time of O(N log N), the expected running time of SELECT is O(N). Explanation for the algorithm is clearly given in the code. * *

**Solution in C**

**Question:** Select the **i**th minimum element in an array with O(N) expected running time.

**Input:**

First line of the input contains T, number of test cases

Each test case contains an integer N ≤ 200, the number of integers in that array, followed by N distinct integers separated by N spaces with **i **in the next line**.**

**Output:** **i**th minimum element.

**Sample Input**

2 5 4 7 9 3 1 3 4 6 10 5 7 1

**Sample Output**

4 5

**Code**

Explanation is given in the gist.

# Quicksort and its Implementation in ‘C’

Like Merge Sort, Quicksort is a **divide and conquer** algorithm. Quicksort first divides the array into two smaller sub-arrays around a picked element called **Pivot**. Then recursively sort the sub-arrays. It works as follows:

- Pick an element, called a
**pivot**, from the array. - Reorder the array such that all the elements before pivot are less than pivot value, while all elements after pivot are grater than or equal to pivot. After this operation, the pivot is in its final position. This is the key process in quicksort, called the
**partition().** - Recursively apply this to the sub-arrays before and after the pivot. Look at this example.

There are different variants of Quicksort that pick pivots in different ways:

- First element of array.
- Last element of array.(used in the following implementation)
- Random element of array.
- Middle index element of array.

**Complexities**

Time complexity :O( N log N -- N log N -- N² )[Best -- Average -- Worst] Memory :O(N or log N)# auxiliary i.e. apart from storing input array Stable : No i.e. can change relative order of elements with same key # N being the number of elements in the array

Other popular sorting algorithms’ complexities are given here.

**Usage and advantages**

# Merge Sort and its Implementation in ‘C’

Merge sort is an advanced sorting algorithm, derived from **divide and conquer** algorithmic paradigm. It works as follows:

1. Divide unsorted array into N sub-arrays, each containing one element. (which is sorted already)

2. Repeatedly merge these sub-arrays to produce sorted new ones until only 1 sub-array is left-out, this is the required sorted array.

Look at the following animation for clear understanding.

**Complexities**

Time complexity :O( N log N -- N log N -- N log N )[Best -- Average -- Worst] Memory :O(N)# auxiliary i.e. apart from storing input array Stable : Yes i.e. doesn't change relative order of elements with same key # N being the number of elements in the array

You can read complexities of other popular sorting algorithms here.

**Usage and Applications**

As of Perl 5.8, merge sort is its default sorting algorithm (it was quicksort in previous versions of Perl). In Java, the Arrays.sort() methods use merge sort or a tuned quicksort depending on the datatypes and for implementation efficiency switch to insertion sort when fewer than seven array elements are being sorted. Merge sort is often the best choice for sorting **linked lists. **Used to find **inversion count** of an array.

**Bottom Line: **Typically, default sort implementation for most of the languages is either Mergesort or Quicksort.