diff --git a/Sorting/1-tutorial-intro.cpp b/Sorting/1-tutorial-intro.cpp
new file mode 100644
index 0000000..046bae9
--- /dev/null
+++ b/Sorting/1-tutorial-intro.cpp
@@ -0,0 +1,25 @@
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+    int n, V;
+    cin >> V >> n;
+
+    int temp = 0;
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> temp;
+        if (temp == V)
+        {
+            cout << i << endl;
+            return 0;
+        }
+    }
+
+    cout << -1 << endl;
+
+    return 0;
+}
diff --git a/Sorting/1-tutorial-intro.php b/Sorting/1-tutorial-intro.php
new file mode 100644
index 0000000..4afe4ad
--- /dev/null
+++ b/Sorting/1-tutorial-intro.php
@@ -0,0 +1,8 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%s", $V);
+fscanf($handle, "%n", $n);
+$ar = explode(' ', trim(fgets($handle)));
+
+echo array_search($V, $ar);
diff --git a/Sorting/10-quicksort4.php b/Sorting/10-quicksort4.php
new file mode 100644
index 0000000..f3895b5
--- /dev/null
+++ b/Sorting/10-quicksort4.php
@@ -0,0 +1,53 @@
+<?php
+
+function insertionSort($arr){
+    $times = 0;
+
+    for ($i=1; $i < count($arr); $i++) {
+        $val = $arr[$i];
+        for ($j=$i - 1; $j >= 0; $j--) {
+            if ($val < $arr[$j]) {
+                $arr[$j + 1] = $arr[$j];
+                $arr[$j] = $val;
+                $times ++;
+            } else {
+                break;
+            }
+        }
+    }
+
+    return $times;
+}
+
+function quickSort($arr, $start, $end) {
+    global $times_2;
+
+    if ($end - $start < 2)
+        return;
+    $p = $arr[$end - 1];
+    $i = $start;
+    for ($j=$start; $j < $end; $j++) {
+        if ($arr[$j] <= $p) {
+            $temp = $arr[$i];
+            $arr[$i] = $arr[$j];
+            $arr[$j] = $temp;
+            $times_2 ++;
+            $i ++;
+        }
+    }
+
+    quickSort($arr, $start, $i - 1);
+    quickSort($arr, $i, $end);
+
+    return $times_2;
+}
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $t);
+
+$arr = explode(' ', trim(fgets($handle)));
+
+global $times_2;
+$times_2 = 0;
+
+echo insertionSort($arr) - quickSort($arr, 0, count($arr)) . PHP_EOL;
diff --git a/Sorting/11-countingsort1.php b/Sorting/11-countingsort1.php
new file mode 100644
index 0000000..c81b8e1
--- /dev/null
+++ b/Sorting/11-countingsort1.php
@@ -0,0 +1,22 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $t);
+
+$arr = explode(' ', trim(fgets($handle)));
+
+$max = max($arr);
+
+$results = [];
+
+for ($i=0; $i <= $max; $i++) {
+    $results[$i] = 0;
+}
+
+foreach ($arr as $a) {
+    $results[$a] ++;
+}
+
+for ($i=0; $i <= $max; $i++) {
+    echo $results[$i] . ' ';
+}
diff --git a/Sorting/12-countingsort2.php b/Sorting/12-countingsort2.php
new file mode 100644
index 0000000..324bcbc
--- /dev/null
+++ b/Sorting/12-countingsort2.php
@@ -0,0 +1,24 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $t);
+
+$arr = explode(' ', trim(fgets($handle)));
+$max = max($arr);
+$results = [];
+
+for ($i=0; $i <= $max; $i++) {
+    $results[$i] = 0;
+}
+
+foreach ($arr as $a) {
+    $results[$a] ++;
+}
+
+$results = array_filter($results, function($result) {
+    return $result != 0;
+});
+
+foreach ($results as $key => $value) {
+    echo str_repeat("$key ", $value);
+}
diff --git a/Sorting/13-countingsort3.php b/Sorting/13-countingsort3.php
new file mode 100644
index 0000000..0f80424
--- /dev/null
+++ b/Sorting/13-countingsort3.php
@@ -0,0 +1,20 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $t);
+
+$str = [];
+$a = [];
+$count = array_fill(0, 101, 0);
+for ($i=0; $i < $t; $i++) {
+    fscanf($handle, "%d %s", $a[$i], $str[]);
+    $count[$a[$i]] ++;
+}
+
+for ($i=0; $i < 100; $i++) {
+    if ($i != 0) {
+        $count[$i] = $count[$i] + $count[$i - 1];
+    }
+
+    printf("%d ", $count[$i]);
+}
diff --git a/Sorting/14-countingsort4.cpp b/Sorting/14-countingsort4.cpp
new file mode 100644
index 0000000..27efab2
--- /dev/null
+++ b/Sorting/14-countingsort4.cpp
@@ -0,0 +1,38 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+vector <string> a[100];
+string str;
+int n, i, j, x;
+
+int main(int argc, char const *argv[])
+{
+    cin >> n;
+    for (i = 0; i < n / 2; ++i)
+    {
+        cin >> x;
+        cin >> str;
+        a[x].push_back("-");
+    }
+
+    for (; i < n; ++i)
+    {
+        cin >> x;
+        cin >> str;
+        a[x].push_back(str);
+    }
+
+    for (i = 0; i < 100; ++i)
+    {
+        x = a[i].size();
+        for (int j = 0; j < x; ++j)
+        {
+            cout << a[i][j] << " ";
+        }
+    }
+
+    return 0;
+}
diff --git a/Sorting/14-countingsort4.php b/Sorting/14-countingsort4.php
new file mode 100644
index 0000000..f5aef67
--- /dev/null
+++ b/Sorting/14-countingsort4.php
@@ -0,0 +1,27 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $t);
+
+$array = [];
+$out = [];
+
+$i = 0;
+while ($ar = trim(fgets($handle))) {
+    $i ++;
+    list($a, $s) = explode(' ', $ar);
+    if ($i <= $t / 2) {
+        $s = '-';
+    }
+    $array[(int)$a][] = $s;
+}
+
+ksort($array);
+
+foreach ($array as $s) {
+    foreach ($s as $x) {
+        $out[] = $x;
+    }
+}
+
+echo implode(' ', $out);
diff --git a/Sorting/15-closest-numbers.php b/Sorting/15-closest-numbers.php
new file mode 100644
index 0000000..09b26b8
--- /dev/null
+++ b/Sorting/15-closest-numbers.php
@@ -0,0 +1,24 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $n);
+
+$arr = explode(' ', trim(fgets($handle)));
+sort($arr);
+
+$results = [];
+$min = $arr[1] - $arr[0];
+$mins = [1];
+
+for ($i=2; $i < $n; $i++) {
+    if ($arr[$i] - $arr[$i - 1] < $min) {
+        $min = $arr[$i] - $arr[$i - 1];
+        $mins = [$i];
+    } else if ($arr[$i] - $arr[$i - 1] == $min) {
+        $mins[] = $i;
+    }
+}
+
+foreach ($mins as $a) {
+    echo $arr[$a - 1] . ' ' . $arr[$a] . ' ';
+}
diff --git a/Sorting/16-find-median.php b/Sorting/16-find-median.php
new file mode 100644
index 0000000..e502bbf
--- /dev/null
+++ b/Sorting/16-find-median.php
@@ -0,0 +1,9 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $n);
+
+$arr = explode(' ', trim(fgets($handle)));
+sort($arr);
+
+echo $arr[floor($n / 2)];
diff --git a/Sorting/17-sherlock-and-watson.php b/Sorting/17-sherlock-and-watson.php
new file mode 100644
index 0000000..3d1b2cf
--- /dev/null
+++ b/Sorting/17-sherlock-and-watson.php
@@ -0,0 +1,18 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d %d %d", $N, $K, $Q);
+
+$A = explode(' ', trim(fgets($handle)));
+
+$times = $K % $N;
+
+while ($Q --) {
+    fscanf($handle, "%d", $a);
+
+    if ($a - $times >= 0) {
+        echo $A[$a - $times] . PHP_EOL;
+    } else {
+        echo $A[$a - $times + $N] . PHP_EOL;
+    }
+}
diff --git a/Sorting/18-almost-sorted.cpp b/Sorting/18-almost-sorted.cpp
new file mode 100644
index 0000000..fa00692
--- /dev/null
+++ b/Sorting/18-almost-sorted.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+typedef long long LL;
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+    LL n;
+    vector <LL> origin, sorted, diff;
+    cin >> n;
+    for (LL i = 0; i < n; ++i) {
+        LL x;
+        cin >> x;
+        origin.push_back(x);
+        sorted.push_back(x);
+    }
+    sort(sorted.begin(), sorted.end());
+
+    for (LL i = 0; i < n; ++i) {
+        if (origin[i] != sorted[i]) {
+            diff.push_back(i);
+        }
+    }
+
+    LL count = diff.size();
+
+    if (count == 0) {
+        cout << "yes" << endl;
+        return 0;
+    }
+
+    if (count == 2 &&
+        sorted[diff[0]] == origin[diff[1]] &&
+        sorted[diff[1]] == origin[diff[0]]) {
+        cout << "yes" << endl << "swap " << diff[0] + 1 << " " << diff.back() + 1;
+        return 0;
+    }
+
+    bool reverse = false;
+    for (LL i = 0; i < count; i ++) {
+        if (origin[diff[i]] == sorted[diff[count - i - 1]]) {
+            reverse = true;
+        } else {
+            reverse = false;
+            break;
+        }
+    }
+
+    if (reverse) {
+        cout << "yes" << endl << "reverse " << diff[0] + 1 << " " << diff.back() + 1;
+    } else {
+        cout << "no" << endl;
+    }
+
+    return 0;
+}
diff --git a/Sorting/18-almost-sorted.php b/Sorting/18-almost-sorted.php
new file mode 100644
index 0000000..6ca52cd
--- /dev/null
+++ b/Sorting/18-almost-sorted.php
@@ -0,0 +1,41 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $n);
+
+$origin = array_map('intval', explode(' ', trim(fgets($handle))));
+$sorted = $origin;
+sort($sorted);
+
+$diff = [];
+for ($i=0; $i < $n; $i++) {
+    if ($origin[$i] != $sorted[$i]) {
+        $diff[] = $i;
+    }
+}
+
+$count = count($diff);
+
+//sorted
+if ($count == 0) {
+    echo "yes\n";
+} else if ($count == 2 && // swap
+    $sorted[$diff[0]] == $origin[$diff[1]] &&
+    $sorted[$diff[1]] == $origin[$diff[0]]) {
+    printf("yes\nswap %d %d\n", $diff[0] + 1, $diff[1] + 1);
+} else if ($count > 2) {
+    $reverse = false;
+    for ($i=0; $i < $count; $i++) {
+        if ($sorted[$diff[$i]] == $origin[$diff[$count - 1 - $i]]) {
+            $reverse = true;
+        } else {
+            $reverse = false;
+            break;
+        }
+    }
+    if ($reverse) {
+        printf("yes\nreverse %d %d\n", $diff[0] + 1, $diff[$count - 1] + 1);
+    } else {
+        echo "no\n";
+    }
+}
diff --git a/Sorting/19-sherlock-and-pairs.php b/Sorting/19-sherlock-and-pairs.php
new file mode 100644
index 0000000..22e4c36
--- /dev/null
+++ b/Sorting/19-sherlock-and-pairs.php
@@ -0,0 +1,27 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $T);
+
+while ($T --) {
+    fscanf($handle, "%d", $n);
+    $arr = array_map('intval', explode(' ', trim(fgets($handle))));
+
+    $times = [];
+    foreach ($arr as $a) {
+        if (isset($times[$a])) {
+            $times[$a] ++;
+        } else {
+            $times[$a] = 1;
+        }
+    }
+
+    $count = 0;
+    foreach ($times as $a) {
+        if ($a == 1) continue;
+
+        $count += ($a - 1) * $a;
+    }
+
+    echo $count . PHP_EOL;
+}
diff --git a/Sorting/2-insertionsort1.php b/Sorting/2-insertionsort1.php
new file mode 100644
index 0000000..4029e98
--- /dev/null
+++ b/Sorting/2-insertionsort1.php
@@ -0,0 +1,29 @@
+<?php
+
+function insertSort($arr)
+{
+    $count = count($arr);
+    $last = $arr[$count - 1];
+
+    for ($i=$count - 2; $i >= 0; $i--) {
+        if ($arr[$i] > $last) {
+            $arr[$i + 1] = $arr[$i];
+            echo implode(' ', $arr) . PHP_EOL;
+        } else {
+            $arr[$i + 1] = $last;
+            echo implode(' ', $arr) . PHP_EOL;
+            break;
+        }
+
+        if ($i == 0) {
+            $arr[0] = $last;
+            echo implode(' ', $arr) . PHP_EOL;
+        }
+    }
+}
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $m);
+$ar = explode(' ', trim(fgets($handle)));
+
+insertSort($ar);
diff --git a/Sorting/20-insertion-sort.cpp b/Sorting/20-insertion-sort.cpp
new file mode 100644
index 0000000..5057a89
--- /dev/null
+++ b/Sorting/20-insertion-sort.cpp
@@ -0,0 +1,68 @@
+/* Enter your code here. Read input from STDIN. Print output to STDOUT */
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+#include <stdio.h>
+
+using namespace std ;
+
+long long cnt=0 ;
+
+void merge(int a[],int p,int q,int r)
+{
+    int l1[q-p+1] ;
+    int r1[r-q] ;
+    int n1=q-p+1 ;
+    int n2=r-q ;
+    int pos1=0,pos2=0 ;
+    for(int i=p;i<=q;i++)
+        l1[pos1++]=a[i] ;
+    for(int i=q+1;i<=r;i++)
+        r1[pos2++]=a[i] ;
+    int size=pos1 ;
+    int pos3=p ;
+    pos1=pos2=0 ;
+    while(pos1<n1 && pos2<n2){
+        if(l1[pos1]>r1[pos2]){
+            cnt+=size-pos1 ;
+            a[pos3++]=r1[pos2++] ;
+        }else
+            a[pos3++]=l1[pos1++] ;
+    }
+    if(pos1>=n1){
+        while(pos2<n2)
+            a[pos3++]=r1[pos2++] ;
+    }else{
+        while(pos1<n1)
+            a[pos3++]=l1[pos1++] ;
+
+    }
+}
+
+void merge_sort(int a[],int p,int r)
+{
+    if(p<r){
+        int q=(p+r)/2 ;
+        merge_sort(a,p,q) ;
+        merge_sort(a,q+1,r) ;
+        merge(a,p,q,r) ;
+    }
+}
+
+int main()
+{
+    int t ;
+    scanf("%d",&t) ;
+    while(t) {
+        int n ;
+        scanf("%d",&n) ;
+        int A[n] ;
+        for(int i=0;i<n;i++)
+            scanf("%d",&A[i]) ;
+        merge_sort(A,0,n-1) ;
+        cout << cnt << endl ;
+        cnt = 0 ;
+        t-- ;
+    }
+    return 0 ;
+}
diff --git a/Sorting/20-insertion-sort.php b/Sorting/20-insertion-sort.php
new file mode 100644
index 0000000..19e9150
--- /dev/null
+++ b/Sorting/20-insertion-sort.php
@@ -0,0 +1,59 @@
+<?php
+
+// timeout.
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $t);
+
+while ($t --) {
+    fscanf($handle, "%d", $n);
+    $arr = array_map('intval', explode(' ', trim(fgets($handle))));
+
+    $count = countShifts($arr);
+
+    echo $count . PHP_EOL;
+}
+
+function countShifts(&$array) {
+    $count = count($array);
+    if ($count < 2) {
+        return 0;
+    }
+
+    $middle = (int) ($count / 2);
+    //make left
+    for ($i=0; $i < $middle; $i++) {
+        $left[] = $array[$i];
+    }
+    // make right
+    for ($i=$middle; $i < $count; $i++) {
+        $right[] = $array[$i];
+    }
+
+    return countShifts($left) + countShifts($right) + merge($array, $left, $right);
+}
+
+function merge(&$array, $left, $right) {
+    $inversions_count = 0;
+    $i = 0;
+    $j = 0;
+    $left_count = count($left);
+    $right_count = count($right);
+    while ($i < $left_count || $j < $right_count) {
+        if ($i == $left_count) {
+            $array[$i + $j] = $right[$j];
+            $j ++;
+        } else if ($j == $right_count) {
+            $array[$i + $j] = $left[$i];
+            $i ++;
+        } else if ($left[$i] <= $right[$j]) {
+            $array[$i + $j] = $left[$i];
+            $i ++;
+        } else {
+            $array[$i + $j] = $right[$j];
+            $inversions_count += $left_count - $i;
+            $j ++;
+        }
+    }
+
+    return $inversions_count;
+}
diff --git a/Sorting/3-insertionsort2.php b/Sorting/3-insertionsort2.php
new file mode 100644
index 0000000..d281ca9
--- /dev/null
+++ b/Sorting/3-insertionsort2.php
@@ -0,0 +1,26 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $m);
+$ar = explode(' ', trim(fgets($handle)));
+
+insertSort2($ar);
+
+function insertSort2(array $arr) {
+    $count = count($arr);
+
+    for ($i=1; $i < $count; $i++) {
+        $temp = $arr[$i];
+
+        for ($j=$i - 1; $j >= 0; $j--) {
+            if ($temp < $arr[$j]) {
+                $arr[$j + 1] = $arr[$j];
+                $arr[$j] = $temp;
+            } else {
+                break;
+            }
+        }
+
+        echo implode(" ", $arr) . PHP_EOL;
+    }
+}
diff --git a/Sorting/4-correctness-invariant.php b/Sorting/4-correctness-invariant.php
new file mode 100644
index 0000000..1291121
--- /dev/null
+++ b/Sorting/4-correctness-invariant.php
@@ -0,0 +1,25 @@
+<?php
+
+function insertionSort(&$arr){
+   for ($i=1; $i < count($arr); $i++) {
+      $val = $arr[$i];
+      for ($j=$i - 1; $j >= 0; $j--) {
+         if ($val < $arr[$j]) {
+            $arr[$j + 1] = $arr[$j];
+            $arr[$j] = $val;
+         } else {
+            break;
+         }
+      }
+   }
+}
+
+$handle = fopen ("php://stdin","r");
+$t = fgets($handle);
+$arr = split(' ', fgets($handle));
+
+insertionSort($arr);
+
+foreach($arr as $value) {
+  print $value." ";
+}
diff --git a/Sorting/5-runningtime.php b/Sorting/5-runningtime.php
new file mode 100644
index 0000000..b84311d
--- /dev/null
+++ b/Sorting/5-runningtime.php
@@ -0,0 +1,27 @@
+<?php
+
+function insertionSort($arr){
+    $times = 0;
+
+    for ($i=1; $i < count($arr); $i++) {
+      $val = $arr[$i];
+      for ($j=$i - 1; $j >= 0; $j--) {
+         if ($val < $arr[$j]) {
+            $arr[$j + 1] = $arr[$j];
+            $arr[$j] = $val;
+
+            $times ++;
+         } else {
+            break;
+         }
+      }
+   }
+
+   echo $times . PHP_EOL;
+}
+
+$handle = fopen ("php://stdin","r");
+$t = fgets($handle);
+$arr = split(' ', fgets($handle));
+
+insertionSort($arr);
diff --git a/Sorting/6-quicksort1.php b/Sorting/6-quicksort1.php
new file mode 100644
index 0000000..338b26f
--- /dev/null
+++ b/Sorting/6-quicksort1.php
@@ -0,0 +1,25 @@
+<?php
+
+function partition($ar) {
+    $count = count($ar);
+    $equal = $ar[0];
+    $left = [];
+    $right = [];
+
+    for ($i=0; $i < $count; $i++) {
+        if ($ar[$i] >= $equal) {
+            $right[] = $ar[$i];
+        } else {
+            $left[] = $ar[$i];
+        }
+    }
+
+    echo implode(' ', array_merge($left, $right)) . PHP_EOL;
+}
+
+$fp = fopen("php://stdin", "r");
+
+fscanf($fp, "%d", $m);
+$ar = explode(' ', trim(fgets($fp)));
+
+partition($ar);
diff --git a/Sorting/7-quicksort2.php b/Sorting/7-quicksort2.php
new file mode 100644
index 0000000..f14fa6c
--- /dev/null
+++ b/Sorting/7-quicksort2.php
@@ -0,0 +1,41 @@
+<?php
+
+function quickSort($arr) {
+
+    $count = count($arr);
+
+    if ($count <= 1) return $arr;
+
+    $temp = $arr[0];
+    $left = array();
+    $right = array();
+
+    for ($i = 1; $i < $count; $i ++) {
+        if ($temp > $arr[$i])
+            $left[] = $arr[$i];
+        else
+            $right[] = $arr[$i];
+    }
+
+    if (count($left) > 1) {
+        $left = quickSort($left);
+        echo implode(' ', $left) . PHP_EOL;
+    }
+
+    if (count($right) > 1) {
+        $right = quickSort($right);
+        echo implode(' ', $right) . PHP_EOL;
+    }
+
+    return array_merge($left, [$temp], $right);
+}
+
+$fp = fopen("php://stdin", "r");
+
+fscanf($fp, "%d", $m);
+
+$ar = explode(' ', trim(fgets($fp)));
+
+$results = quickSort($ar);
+
+echo implode(' ', $results) . PHP_EOL;
diff --git a/Sorting/8-quicksort3.cpp b/Sorting/8-quicksort3.cpp
new file mode 100644
index 0000000..beb1005
--- /dev/null
+++ b/Sorting/8-quicksort3.cpp
@@ -0,0 +1,50 @@
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+void quicksort(vector<int> &vec, int startIndex, int pivotIndex)
+{
+    int pivot, index, isgreater;
+    int arraySize = pivotIndex - startIndex;
+    pivot = vec[pivotIndex];
+
+    if (arraySize > 0) {
+        index = startIndex;
+        isgreater = 0;
+        for(int i=startIndex;i<pivotIndex;i++) {
+            if (vec[i]<=pivot) {
+                if(isgreater == 1) {
+                    swap(vec[i], vec[index]);
+                }
+                index++;
+            } else
+                isgreater = 1;
+        }
+        swap(vec[index], vec[pivotIndex]);
+
+        for(int i : vec) {
+            cout << i << " ";
+        }
+        cout << endl;
+
+        quicksort(vec, startIndex, index-1);
+        quicksort(vec, index+1, pivotIndex);
+    }
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */
+    int size;
+    vector<int> vec;
+    cin >> size;
+    for(int i = 0; i<size; i++) {
+        int dummy;
+        cin >> dummy;
+        vec.push_back(dummy);
+    }
+    quicksort(vec, 0, size-1);
+    return 0;
+}
diff --git a/Sorting/8-quicksort3.php b/Sorting/8-quicksort3.php
new file mode 100644
index 0000000..0a06715
--- /dev/null
+++ b/Sorting/8-quicksort3.php
@@ -0,0 +1,31 @@
+<?php
+
+$_fp = fopen("php://stdin", "r");
+
+$n = trim(fgets($_fp));
+$numbers = explode(' ', trim(fgets($_fp)));
+quicksort($numbers, 0, $n-1);
+
+function quicksort(array &$data, $start, $end) {
+    if ($start < $end) {
+        $p = partition($data, $start, $end);
+        quicksort($data, $start, $p - 1);
+        quicksort($data, $p + 1, $end);
+    }
+}
+
+function partition(array &$input, $start, $end) {
+    $firstHigh = $start;
+    $p = $input[$end];
+    for ($i=$start; $i < $end; $i++) {
+        if ($p > $input[$i]) {
+            $tmp = $input[$i];
+            $input[$i] = $input[$firstHigh];
+            $input[$firstHigh++] = $tmp;
+        }
+    }
+    $input[$end] = $input[$firstHigh];
+    $input[$firstHigh] = $p;
+    echo implode(' ', $input) . PHP_EOL;
+    return $firstHigh;
+}
diff --git a/Sorting/9-bigger-is-greater.cpp b/Sorting/9-bigger-is-greater.cpp
new file mode 100644
index 0000000..59e5ae4
--- /dev/null
+++ b/Sorting/9-bigger-is-greater.cpp
@@ -0,0 +1,25 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+    int T;
+    cin >> T;
+    while (T --) {
+        string s;
+        cin >> s;
+        string prev = s;
+        if (next_permutation(s.begin(), s.end()))
+        {
+            cout << s << endl;
+        }
+        else
+        {
+            cout << "no answer" << endl;
+        }
+    }
+
+    return 0;
+}
diff --git a/Sorting/9-bigger-is-greater.php b/Sorting/9-bigger-is-greater.php
new file mode 100644
index 0000000..76cc437
--- /dev/null
+++ b/Sorting/9-bigger-is-greater.php
@@ -0,0 +1,48 @@
+<?php
+
+$_fp = fopen("php://stdin", "r");
+fscanf($_fp, "%d", $t);
+
+while ($t --) {
+    $str = trim(fgets($_fp));
+
+    if (next_permutation($str)) {
+        echo "$str\n";
+    } else {
+        echo "no answer\n";
+    }
+}
+
+function next_permutation(&$str) {
+    $length = strlen($str);
+    $i = $length - 1;
+    while ($i > 0 && $str[$i - 1] >= $str[$i]) {
+        $i --;
+    }
+
+    // no nect permutation.
+    if ($i <= 0) return false;
+
+    // search right greater pivot.
+    $j = $length - 1;
+    while ($str[$j] <= $str[$i - 1]) {
+        $j --;
+    }
+
+    // change pivot and right.
+    $temp = $str[$i - 1];
+    $str[$i - 1] = $str[$j];
+    $str[$j] = $temp;
+
+    // reverse.
+    $j = $length - 1;
+    while ($i < $j) {
+        $temp = $str[$i];
+        $str[$i] = $str[$j];
+        $str[$j] = $temp;
+        $i ++;
+        $j --;
+    }
+
+    return true;
+}
diff --git a/Sorting/a.out b/Sorting/a.out
new file mode 100755
index 0000000..7343749
Binary files /dev/null and b/Sorting/a.out differ
diff --git a/string/1-pangrams.c b/String/1-pangrams.c
similarity index 100%
rename from string/1-pangrams.c
rename to String/1-pangrams.c
diff --git a/string/1-pangrams.php b/String/1-pangrams.php
similarity index 100%
rename from string/1-pangrams.php
rename to String/1-pangrams.php
diff --git a/string/10-palindrome-index.php b/String/10-palindrome-index.php
similarity index 100%
rename from string/10-palindrome-index.php
rename to String/10-palindrome-index.php
diff --git a/string/11-reverse-shuffle-merge.php b/String/11-reverse-shuffle-merge.php
similarity index 100%
rename from string/11-reverse-shuffle-merge.php
rename to String/11-reverse-shuffle-merge.php
diff --git a/string/12-the-love-letter-mystery.cpp b/String/12-the-love-letter-mystery.cpp
similarity index 100%
rename from string/12-the-love-letter-mystery.cpp
rename to String/12-the-love-letter-mystery.cpp
diff --git a/string/12-the-love-letter-mystery.php b/String/12-the-love-letter-mystery.php
similarity index 100%
rename from string/12-the-love-letter-mystery.php
rename to String/12-the-love-letter-mystery.php
diff --git a/string/13-common-child.cpp b/String/13-common-child.cpp
similarity index 100%
rename from string/13-common-child.cpp
rename to String/13-common-child.cpp
diff --git a/String/14-morgan-and-a-string.php b/String/14-morgan-and-a-string.php
new file mode 100644
index 0000000..6cbfa50
--- /dev/null
+++ b/String/14-morgan-and-a-string.php
@@ -0,0 +1,29 @@
+<?php
+
+// to do...
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $T);
+
+while ($T --) {
+    fscanf($handle, "%s", $str1);
+    fscanf($handle, "%s", $str2);
+
+    $length = strlen($str1);
+
+    $index_1 = 0;
+    $index_2 = 0;
+
+    $result = '';
+    while ($index_1 < $length - 1 && $index_2 < $length - 1) {
+        if (compare($str1, $str2, $index_1, $index_2) < 0) {
+
+        } else {
+
+        }
+    }
+}
+
+function compare($a, $b, $i, $j) {
+    // $length_1 = strlen($a) - $i
+}
+
diff --git a/String/15-sherlock-and-valid-string.php b/String/15-sherlock-and-valid-string.php
new file mode 100644
index 0000000..61a885a
--- /dev/null
+++ b/String/15-sherlock-and-valid-string.php
@@ -0,0 +1,22 @@
+<?php
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%s", $str);
+
+$letters = [];
+
+foreach (range('a', 'z') as $letter) {
+    if (substr_count($str, $letter)) {
+        $letters[] = substr_count($str, $letter);
+    }
+}
+
+$max = max($letters);
+$min = min($letters);
+if ($max == $min) {
+    echo "YES\n";
+} else if ((array_count_values($letters)[$min] == 1 && ($min == 1 || $min - $max == 1)) || (array_count_values($letters)[$max] == 1 && ($max == 1 || $max - $min == 1))) {
+    echo "YES\n";
+} else {
+    echo "NO\n";
+}
diff --git a/String/16-count-string.php b/String/16-count-string.php
new file mode 100644
index 0000000..98b4f82
--- /dev/null
+++ b/String/16-count-string.php
@@ -0,0 +1,3 @@
+<?php
+
+echo "So difficult";
diff --git a/String/17-string-function-calculation.cpp b/String/17-string-function-calculation.cpp
new file mode 100644
index 0000000..5715d7e
--- /dev/null
+++ b/String/17-string-function-calculation.cpp
@@ -0,0 +1,11 @@
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+int main(int argc, char const *argv[])
+{
+    //
+
+    return 0;
+}
diff --git a/String/17-string-function-calculation.php b/String/17-string-function-calculation.php
new file mode 100644
index 0000000..f00623d
--- /dev/null
+++ b/String/17-string-function-calculation.php
@@ -0,0 +1,37 @@
+<?php
+
+// php time out.
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%s", $str);
+
+$length = strlen($str);
+
+$max = $length;
+$collection = [];
+
+for ($i=1; $i < $length + 1; $i++) {
+    for ($j=0; $j < $length + 1 - $i ; $j++) {
+        $current = substr($str, $j, $i);
+        if (! in_array($current, $collection)) {
+            $collection[] = $current;
+            $count = 0;
+            $start = $j;
+
+            if (strlen($current) > 1 && $current[0] == $current[1]) {
+                while (($pos = strpos($str, $current, $start)) !== false) {
+                    $count ++;
+                    $start = $pos + 1;
+                }
+            } else {
+                $count = substr_count($str, $current);
+            }
+
+            if (($count * $i) > $max) {
+                $max = $count * $i;
+            }
+        }
+    }
+}
+
+echo $max . PHP_EOL;
diff --git a/string/2-funny-string.cpp b/String/2-funny-string.cpp
similarity index 100%
rename from string/2-funny-string.cpp
rename to String/2-funny-string.cpp
diff --git a/string/2-funny-string.php b/String/2-funny-string.php
similarity index 100%
rename from string/2-funny-string.php
rename to String/2-funny-string.php
diff --git a/String/22-string-similarity.cpp b/String/22-string-similarity.cpp
new file mode 100644
index 0000000..6acefd1
--- /dev/null
+++ b/String/22-string-similarity.cpp
@@ -0,0 +1,124 @@
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+typedef long int l;
+
+long int z_func(const string &s)
+{
+    l sum = 0;
+    l length = s.length();
+    l Z[length] = {0};
+    l left = 0;
+    l right = 0;
+    for (l k = 1; k < length; ++k)
+    {
+        if (k > right) {
+            left = right = k;
+            while (right < length && s[right] == s[right - left]) {
+                right ++;
+            }
+            Z[k] = right - left;
+            right --;
+        } else {
+            int k1 = k - left;
+            if (Z[k1] < right - k + 1) {
+                Z[k] = Z[k1];
+            } else {
+                left = k;
+                while (right < length && s[right] == s[right - left]) {
+                    right ++;
+                }
+                Z[k] = right - left;
+                right --;
+            }
+        }
+    }
+
+    for (l i = 0; i < length; ++i)
+    {
+        sum += Z[i];
+    }
+
+    return sum;
+}
+
+int main(int argc, char const *argv[])
+{
+    int T;
+    cin >> T;
+    while (T --) {
+        string s;
+        cin >> s;
+        l res = z_func(s);
+
+        cout << s.length() + res << endl;
+    }
+
+    return 0;
+}
+
+
+// timeout ...
+// #include <iostream>
+// #include <string>
+
+// using namespace std;
+
+// long int match(const string &str1, const string &str2)
+// {
+//     if (str1.empty() || str2.empty()) {
+//         return 0;
+//     }
+//     long int length = str2.length();
+
+//     int maxSubstr = 0;
+//     for (long int i = 0; i < length; ++i)
+//     {
+//         if (str2[i] == str1[i])
+//             maxSubstr ++;
+//         else
+//             break;
+//     }
+
+//     return maxSubstr;
+// }
+
+// long int stringSimilarity(string s)
+// {
+//     // soso.
+//     long int length = s.length();
+//     long int index[length];
+//     long int i = 0;
+//     long int c= 0;
+//     long int count= 0;
+//     while (s[i] != '\0') {
+//         if (s[i] == s[0]) {
+//             index[c] = i;
+//             c ++;
+//         }
+//         i ++;
+//     }
+
+//     for (i = 0; i < c; ++i)
+//     {
+//         string s1 = s.substr(index[i], length);
+//         count += match(s, s1);
+//     }
+
+//     return count;
+// }
+
+// int main(int argc, char const *argv[])
+// {
+//     int T;
+//     cin >> T;
+//     while (T --) {
+//         string s;
+//         cin >> s;
+//         cout << stringSimilarity(s) << endl;
+//     }
+
+//     return 0;
+// }
diff --git a/String/22-string-similarity.php b/String/22-string-similarity.php
new file mode 100644
index 0000000..6b4b921
--- /dev/null
+++ b/String/22-string-similarity.php
@@ -0,0 +1,28 @@
+<?php
+
+// timeout.. cpp
+
+$handle = fopen("php://stdin", "r");
+fscanf($handle, "%d", $T);
+
+while ($T --) {
+    fscanf($handle, "%s", $str);
+
+    $res = stringSimilarity($str);
+    echo "$res\n";
+}
+
+function stringSimilarity($s) {
+    $letters = str_split($s);
+    $length = count($letters);
+    $count = $length;
+    for ($i=1; $i < $length; $i++) {
+        $j = 0;
+        while ($letters[$j] == $letters[$j + $i]) {
+            $j ++;
+        }
+        $count += $j;
+    }
+
+    return $count;
+}
diff --git a/string/3-alternating-characters.cpp b/String/3-alternating-characters.cpp
similarity index 100%
rename from string/3-alternating-characters.cpp
rename to String/3-alternating-characters.cpp
diff --git a/string/3-alternating-characters.php b/String/3-alternating-characters.php
similarity index 100%
rename from string/3-alternating-characters.php
rename to String/3-alternating-characters.php
diff --git a/string/4-game-of-thrones.cpp b/String/4-game-of-thrones.cpp
similarity index 100%
rename from string/4-game-of-thrones.cpp
rename to String/4-game-of-thrones.cpp
diff --git a/string/4-game-of-thrones.php b/String/4-game-of-thrones.php
similarity index 100%
rename from string/4-game-of-thrones.php
rename to String/4-game-of-thrones.php
diff --git a/string/5-gem-stones.cpp b/String/5-gem-stones.cpp
similarity index 100%
rename from string/5-gem-stones.cpp
rename to String/5-gem-stones.cpp
diff --git a/string/5-gem-stones.php b/String/5-gem-stones.php
similarity index 100%
rename from string/5-gem-stones.php
rename to String/5-gem-stones.php
diff --git a/string/6-make-it-anagram.cpp b/String/6-make-it-anagram.cpp
similarity index 100%
rename from string/6-make-it-anagram.cpp
rename to String/6-make-it-anagram.cpp
diff --git a/string/6-make-it-anagram.php b/String/6-make-it-anagram.php
similarity index 100%
rename from string/6-make-it-anagram.php
rename to String/6-make-it-anagram.php
diff --git a/string/7-anagram.cpp b/String/7-anagram.cpp
similarity index 100%
rename from string/7-anagram.cpp
rename to String/7-anagram.cpp
diff --git a/string/7-anagram.php b/String/7-anagram.php
similarity index 100%
rename from string/7-anagram.php
rename to String/7-anagram.php
diff --git a/string/8-two-string.cpp b/String/8-two-string.cpp
similarity index 100%
rename from string/8-two-string.cpp
rename to String/8-two-string.cpp
diff --git a/string/8-two-string.php b/String/8-two-string.php
similarity index 100%
rename from string/8-two-string.php
rename to String/8-two-string.php
diff --git a/string/9-sherlock-and-anagrams.cpp b/String/9-sherlock-and-anagrams.cpp
similarity index 100%
rename from string/9-sherlock-and-anagrams.cpp
rename to String/9-sherlock-and-anagrams.cpp
diff --git a/String/a.out b/String/a.out
new file mode 100755
index 0000000..0ad0b52
Binary files /dev/null and b/String/a.out differ
diff --git a/string/13-common-child b/string/13-common-child
deleted file mode 100755
index 1f2b901..0000000
Binary files a/string/13-common-child and /dev/null differ
diff --git a/string/a.out b/string/a.out
deleted file mode 100755
index baf813f..0000000
Binary files a/string/a.out and /dev/null differ