This post is not yet done.

他動詞五段ぁす／やす | 自動詞一段ぇる／える |
---|---|

溶かす | 溶ける |

砂糖を溶かす | 塩が溶ける |

逃す | 逃げる |

蝉を逃がす | 小鳥が逃げる |

出す | 出る |

船を出す | 月が出る |

枯らす | 枯れる |

植木を枯らす | 葉が枯れる |

増やす | 増える |

人数を増やす | 財産が増える |

他動詞五段 使役形ぁす | 自動詞五段 終止形ぅ |
---|---|

沸かす | 沸く |

湯を沸かす | 風呂が沸く |

乾かす | 乾く |

服を乾かす | 洗濯物が乾く |

喜ばす | 喜ぶ |

彼女を喜ばす | 子供が喜ぶ |

減らす | 減る |

体重を減らす | 収入が減る |

散らす | 散る |

花を散らす | 花が散る |

照らす | 照る |

舞台を照らす | 日が照る |

他動詞一段ぇる/える | 自動詞五段ぁる/わる |
---|---|

伝える | 伝わる |

用件を伝える | 命令が伝わる |

変える | 変わる |

戦術を変える | 顔色が変わる |

加える | 加わる |

危害を加える | 要素が加わる |

始める | 始まる |

戦争を始める | 工事が始まる |

他動詞一段ぇる | 自動詞五段ぅ |
---|---|

開ける | 開く |

目を開ける | 窓が開く |

届ける | 届く |

拾得物を届ける | 手が届く |

育てる | 育つ |

苗を育てる | 麦が育つ |

立てる | 立つ |

本を立てる | 電柱が立つ |

乗せる | 乗る |

荷物を乗せる | 子供が乗る |

寄せる | 寄る |

肩を寄せる | 船が寄る |

To be distinguished from the Porential Form. |

他動詞五段ぅ | 自動詞一段ぇる |
---|---|

抜く | 抜ける |

刀を抜く | 歯が抜ける |

解く | 解ける |

帯を解く | 緊張が解ける |

焼く | 焼ける |

草を焼く | 家が焼ける |

売る | 売れる |

商品を売る | 本が売れる |

外す | 外れる |

錠を離す | 障子が外れる |

離す | 離れる |

付箋を離す | 雀が離れる |

To be distinguished from the Porential Form. |

他動詞五段す | 自動詞五段る |
---|---|

返す | 返る |

借金を返す | 軍配が返る |

他動詞五段ぉす | 自動詞一段ぃる |
---|---|

起こす | 起きる |

倒木を起こす | 混乱が起きる |

他動詞 | 自動詞 |
---|---|

見る | 見える |

星空をみる | 星が見える |

A useful Japanese dictionary that contains etymology is found here.

A few websites for pronunciations:

In most cases the audios could not be directly downloaded. Watch the `Network`

tab in your chrome dev tools. Any audio files received from the server are shown there.

Sorting is a common operation in many applications, and efficient algorithms to perform it have been developed.

Computer manufacturers of the 1960’s estimated that more than 25 percent of the running time of their computers was spent on sorting, when all their customers were taken into account. In fact, there were many installations in which the task of sorting was responsible for more than half of the computing time. From these statistics we may conclude that either

- there are many important applications of sorting, or
- many people sort when they shouldn’t, or
- inefficient sorting algorithms have been in common use.
—

Sorting and Searching,Knuth

- Worst-case performance: \(O(n^2)\)
- Average performance: \(O(n\log n)\)
- Best performance: \(O(n\log n)\)

Quicksort is a comparison sort, meaning that it can sort items of any type for which a "less-than" relation (formally, a total order) is defined. Efficient implementations of Quicksort are not a stable sort, meaning that the relative order of equal sort items is not preserved.

```
/* This function takes last element as pivot, places
the pivot element at its correct position in sorted
array, and places all smaller (smaller than pivot)
to left of pivot and all greater elements to right
of pivot */
int partition (int arr[], int low, int high)
{
int pivot = arr[high]; // pivot
int i = (low - 1); // Index of smaller element
for (int j = low; j <= high- 1; j++)
{
// If current element is smaller than or
// equal to pivot
if (arr[j] <= pivot)
{
i++; // increment index of smaller element
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
/* The main function that implements QuickSort
arr[] --> Array to be sorted,
low --> Starting index,
high --> Ending index */
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
/* pi is partitioning index, arr[p] is now
at right place */
int pi = partition(arr, low, high);
// Separately sort elements before
// partition and after partition
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
```

```
# Python program for implementation of Quicksort Sort
# This function takes last element as pivot, places
# the pivot element at its correct position in sorted
# array, and places all smaller (smaller than pivot)
# to left of pivot and all greater elements to right
# of pivot
def partition(arr, low, high):
i = (low-1) # index of smaller element
pivot = arr[high] # pivot
for j in range(low, high):
# If current element is smaller than or
# equal to pivot
if arr[j] <= pivot:
# increment index of smaller element
i = i+1
arr[i], arr[j] = arr[j], arr[i]
arr[i+1], arr[high] = arr[high], arr[i+1]
return (i+1)
# The main function that implements QuickSort
# arr[] --> Array to be sorted,
# low --> Starting index,
# high --> Ending index
# Function to do Quick sort
def quickSort(arr, low, high):
if len(arr) == 1:
return arr
if low < high:
# pi is partitioning index, arr[p] is now
# at right place
pi = partition(arr, low, high)
# Separately sort elements before
# partition and after partition
quickSort(arr, low, pi-1)
quickSort(arr, pi+1, high)
# Driver code to test above
arr = [10, 7, 8, 9, 1, 5]
n = len(arr)
quickSort(arr, 0, n-1)
print("Sorted array is:")
for i in range(n):
print("%d" % arr[i]),
# This code is contributed by Mohit Kumra
#This code in improved by https://github.com/anushkrishnav
```

- Worst-case performance: \(O(n\log n)\)
- Average performance: \(O(n\log n)\)
- Best performance: \(O(n\log n)\)

Merge sort is an efficient, general-purpose, comparison-based sorting algorithm. Most implementations produce a stable sort, which means that the order of equal elements is the same in the input and output.

```
void merge(int *,int, int , int );
void merge_sort(int *arr, int low, int high)
{
int mid;
if (low < high){
//divide the array at mid and sort independently using merge sort
mid=(low+high)/2;
merge_sort(arr,low,mid);
merge_sort(arr,mid+1,high);
//merge or conquer sorted arrays
merge(arr,low,high,mid);
}
}
// Merge sort
void merge(int *arr, int low, int high, int mid)
{
int i, j, k, c[50];
i = low;
k = low;
j = mid + 1;
while (i <= mid && j <= high) {
if (arr[i] < arr[j]) {
c[k] = arr[i];
k++;
i++;
}
else {
c[k] = arr[j];
k++;
j++;
}
}
while (i <= mid) {
c[k] = arr[i];
k++;
i++;
}
while (j <= high) {
c[k] = arr[j];
k++;
j++;
}
for (i = low; i < k; i++) {
arr[i] = c[i];
}
}
```

```
# Python program for implementation of MergeSort
def mergeSort(arr):
if len(arr) > 1:
# Finding the mid of the array
mid = len(arr)//2
# Dividing the array elements
L = arr[:mid]
# into 2 halves
R = arr[mid:]
# Sorting the first half
mergeSort(L)
# Sorting the second half
mergeSort(R)
i = j = k = 0
# Copy data to temp arrays L[] and R[]
while i < len(L) and j < len(R):
if L[i] < R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
# Checking if any element was left
while i < len(L):
arr[k] = L[i]
i += 1
k += 1
while j < len(R):
arr[k] = R[j]
j += 1
k += 1
# Code to print the list
def printList(arr):
for i in range(len(arr)):
print(arr[i], end=" ")
print()
```

Let \((\hat{\mathbf{x}},\hat{\mathbf{y}},\hat{\mathbf{z}})\) denote the spatial frame (does not rotate with the body) and \((\hat{\mathbf{x}}',\hat{\mathbf{y}}',\hat{\mathbf{z}}')\) denote the body frame.

The following two procedures of rotation are identical.

- Rotate around \(\hat{\mathbf{z}}\) by \(\alpha\).
- Rotate around \(\hat{\mathbf{y}}\) by \(\beta\).
- Rotate around \(\hat{\mathbf{z}}\) by \(\gamma\).

vs.

- Rotate around \(\hat{\mathbf{z}}\) by \(\gamma\).
- Rotate around \(\hat{\mathbf{y}}'\) by \(\beta\).
- Rotate around \(\hat{\mathbf{z}}''\) by \(\alpha\).

In particular, the point \((\theta,\varphi)\) on \(S^2\) may be obtained from both of the above procedures with \(\gamma = \varphi\) and \(\beta=\theta\).

This equivalence has applications in, for example, the Wigner \(D\) matrices.

This note is copied from *Semicolons, colons, and dashes*.

- To help separate items in a list, when some of those items already contain commas.

I bought shiny, ripe apples; small, sweet, juicy grapes; and firm pears.

- To join two sentences.

I went to the grocery store today. I bought a ton of fruit; apples, grapes, and pears were all on sale.

But **NEVER DO THIS**:
*I went to the grocery store today; I bought a ton of fruit; apples, grapes, and pears were all on sale.*

- To announce, introduce, or direct attention to a list, a noun or noun phrase, a quotation, or an example/explanation.

We covered many of the fundamentals in our writing class: grammar, punctuation, style, and voice.

- To join sentences.

Life is like a puzzle: half the fun is in trying to work it out.

- To express time, in titles, and as part of other writing conventions.

To Whom it May Concern: Please accept my application for the position advertised in the News and Observer.

**NEVER DO THESE**:
Using a colon between a verb and its object or complement: *The very best peaches are: those that are grown in the great state of Georgia.*

Using a colon between a preposition and its object: *My favorite cake is made of: carrots, flour, butter, eggs, and cream cheese icing.*

Using a colon after "such as," "including," "especially," and similar phrases: *There are many different types of paper, including: college ruled, wide ruled, and plain copy paper.*

- To set off material for emphasis.

After eighty years of dreaming, the elderly man realized it was time to finally revisit the land of his youth—Ireland.

- To indicate sentence introductions or conclusions.

To improve their health, Americans should critically examine the foods that they eat—fast food, fatty fried foods, junk food, and sugary snacks.

- To mark "bonus phrases."

Even the simplest tasks—washing, dressing, and going to work—were nearly impossible after I broke my leg.

- To break up dialogue.

Mimi began to explain herself, saying, “I was thinking—” “I don’t care what you were thinking,” Rodolpho interrupted.

The environment variable may be assigned by `export root_path=root@zechen.site/root/MyPersonalWebsite/public `