diff --git a/Challenges/check_anagrams.php b/Challenges/check_anagrams.php
new file mode 100644
index 0000000..b2f0e58
--- /dev/null
+++ b/Challenges/check_anagrams.php
@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * The is_anagram() function should determine whether two words are anagrams.
+ */
+
+function is_anagram($wrd_1, $wrd_2){
+
+    if(!ctype_alpha($wrd_1) || !ctype_alpha($wrd_2)){
+        return null;
+    }
+
+    if(count_chars($wrd_1,1) == count_chars($wrd_2,1)){
+        return "This two strings are anagram";
+    }
+
+    return "This two strings are not anagram";
+
+}
+
+print_r(is_anagram('anagram','nagaram')."\n");
+print_r(is_anagram('cat','rat')."\n");
\ No newline at end of file
diff --git a/Challenges/check_palindrome.php b/Challenges/check_palindrome.php
new file mode 100644
index 0000000..3673eba
--- /dev/null
+++ b/Challenges/check_palindrome.php
@@ -0,0 +1,34 @@
+<?php
+
+/**
+ * Check if a string is a Palindrome
+ */
+function check_palindrome(string $str): string{
+
+    try{
+
+        if(strrev($str) == $str){
+
+            return "Is Palindrome";
+
+        }else{
+
+            return "Not Palindrome";
+
+        }
+
+    }catch(\Exception $e){
+
+        exit($e->getMessage());
+        echo "\n\n";
+
+    }
+
+}
+
+echo check_palindrome("DAD");
+echo "\n\n";
+echo check_palindrome("MALAYALAM");
+echo "\n\n";
+echo check_palindrome("MALAYAAM");
+echo "\n\n";
\ No newline at end of file
diff --git a/Sorting/Bubble Sort/bidirectional_bubble_sort.php b/Sorting/Bubble Sort/bidirectional_bubble_sort.php
new file mode 100644
index 0000000..dbb4ead
--- /dev/null
+++ b/Sorting/Bubble Sort/bidirectional_bubble_sort.php	
@@ -0,0 +1,75 @@
+<?php
+
+$unsorted = array(79,13,53,11,94,39,4,28,3,80);
+
+/**
+ * Swap function using a list asignment
+ * @param $arr array 
+ * @param $idx1 int
+ * @param $idx2 int
+ */
+function swap(array &$arr, int $idx1, int $idx2){
+
+    /**
+     * Use list to assign values from a given array
+     */
+    list($arr[$idx1], $arr[$idx2]) = array($arr[$idx2],$arr[$idx1]);
+
+}
+
+/**
+ * Bidirecctional Bubble Sort
+ * TODO: implement using threads
+ */
+function bi_bubble_sort(array &$unsorted) : array{
+
+    $swap = true;
+    $array_count = count($unsorted) - 1;
+
+    do{
+
+        $swap = false;
+
+        // sort left directional
+        for($idx = 0; $idx <= $array_count; $idx++){
+
+            $comp = $idx + 1;
+            if(isset($unsorted[$comp]) && $unsorted[$idx] > $unsorted[$comp]){
+                swap($unsorted,$idx, $comp);
+                $swap = true;
+                echo "swap left \n";
+            }
+
+        }
+
+        // break if no sort
+        if($swap == false){
+            break;
+        }
+
+        // Sort right directional
+        for($idx = $array_count; $idx >= 0; $idx--){
+
+            $comp = $idx - 1;
+            if(isset($unsorted[$comp]) && $unsorted[$idx] < $unsorted[$comp]){
+                swap($unsorted, $idx, $comp);
+                $swap = true;
+                echo "swap right \n";
+            }
+
+        }
+
+    }while($swap);
+
+    // return array
+    return $unsorted;
+
+}
+
+// print results
+echo "\n";
+$sorted = bi_bubble_sort($unsorted);
+foreach($sorted as $val){
+    echo $val, " ";
+}
+echo "\n";
\ No newline at end of file
diff --git a/Sorting/Bubble Sort/bubble_sort.php b/Sorting/Bubble Sort/bubble_sort.php
new file mode 100644
index 0000000..1e5eb65
--- /dev/null
+++ b/Sorting/Bubble Sort/bubble_sort.php	
@@ -0,0 +1,51 @@
+<?php
+
+$unsorted = array(79,13,53,11,94,39,4,28,3,80);
+
+/**
+ * Swap function using list assingment
+ */
+function swap(array &$to_sort, $idx1, $idx2){
+
+    /**
+     * Using list to make assignment from constructed array
+     */
+    list($to_sort[$idx1],$to_sort[$idx2]) = array($to_sort[$idx2], $to_sort[$idx1]);
+}
+
+/**
+ * Sorting function using a do while
+ */
+function bubble_sort(array &$unsorted): array{
+
+    // swap idx
+    $swap = true;
+    do{
+
+        $swap = false;
+        // sort
+        foreach($unsorted as $idx => $val){
+
+            if(isset($unsorted[$idx + 1]) && $unsorted[$idx] > $unsorted[$idx + 1]){
+                // swap
+                swap($unsorted, $idx, $idx + 1);
+                $swap = true;
+            }
+
+        }
+
+    }while($swap);
+
+    return $unsorted;
+
+}
+
+
+$sorted = bubble_sort($unsorted);
+
+// print list
+echo "\n";
+foreach( $sorted as $val){
+    echo $val," ";
+}
+echo "\n";
\ No newline at end of file
diff --git a/Sorting/Counting Sort/countingSort_1.php b/Sorting/Counting Sort/countingSort_1.php
new file mode 100644
index 0000000..ef3d456
--- /dev/null
+++ b/Sorting/Counting Sort/countingSort_1.php	
@@ -0,0 +1,101 @@
+<?php
+
+$randomSeq = array(5,14,3,2,23,3,40,38,3,4,41,8,18);
+
+/**
+ * Counting Sort algorithm for positve intergers
+ * @param $rand Array
+ * @return Array sorted array
+ */
+function countingSort(array &$rand): array{
+
+    // output array
+    $output = array(count($rand));
+
+    /**
+     * unsorted array size [$rand] - for [n] elements
+     * Total size of [n] elements in the unsorted array 
+     */
+    $array_size = count($rand);
+
+    /**
+     * find the max value in the range of [n] elements
+     */
+    $max_val = max($rand);
+
+    /**
+     * create counting slots - for [k] elements in range
+     * In this instance [k] will equal the max value in 
+     * range.
+     */
+    $count = array_fill(0, $max_val + 1,0);
+
+    /**
+     * Count all occurances of range items within the given array 
+     * Range in this instance will be from 0 - (k + 1), with k being
+     * the max value from the given array.
+     */
+    foreach($rand as $key => $val){
+
+        /**
+         * Increament value correponding to value
+         * i.e $count[2]++
+         */
+        $count[$val]++;
+
+    }
+
+    /**
+     * Store the cummulative count of each element
+     * Iterate count array and set start index position of 
+     * counted elements.
+     */
+    for($idx = 1; $idx <= $max_val; $idx++){
+
+        /**
+         * We are adding the previous index's count 
+         * to the current count. This will continue 
+         * for [k] range of elements. 
+         */
+        $count[$idx] = ($count[$idx] + $count[$idx - 1]);
+
+    }
+
+    // Find the index of each element
+    for ($idx = $array_size - 1; $idx >= 0; $idx--) {
+
+        /**
+         * So we use the value at the current index pointed to. 
+         * We then grap its cummulative value
+         * and adjust to correct position, by subtracting 1.
+         */
+        $index = ($count[$rand[$idx]] - 1); 
+
+        /**
+         * We then store the value from the original
+         * array in the adjusted postion.
+         */
+        $output[$index] = $rand[$idx];
+
+        /**
+         * We then decreament the current stored value to reflect 
+         * the moved value.
+         */
+        $count[$rand[$idx]]--;
+
+    }
+
+
+    // Copy the sorted array into the original array
+    for($idx = 0; $idx <= $array_size - 1; $idx++){
+
+        // move to correct position
+        $rand[$idx] = $output[$idx];
+
+    }
+
+    return $rand;
+
+}
+
+print_r(countingSort($randomSeq));
\ No newline at end of file
diff --git a/Sorting/trivia/group_by_value.php b/Sorting/trivia/group_by_value.php
new file mode 100644
index 0000000..77cd70c
--- /dev/null
+++ b/Sorting/trivia/group_by_value.php
@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * group array
+ */
+$arr = array(
+"chimpanzee" => 20,
+"meeting" => 50,
+"dynasty" => 20,
+"chocolate" => 20,
+"bananas" => 50,
+"fantasy" => 30,
+"football" => 20
+);
+
+
+function group_by_value(array &$arr): array{
+
+    $results = [];
+
+    foreach($arr as $key => $val){
+
+        $results[$val][] = $key;
+
+    }
+
+    return $results;
+
+}
+
+print_r(group_by_value($arr));
\ No newline at end of file
diff --git a/Sorting/trivia/oddEven.php b/Sorting/trivia/oddEven.php
new file mode 100644
index 0000000..81f2e57
--- /dev/null
+++ b/Sorting/trivia/oddEven.php
@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * Separate odd and even number
+ */
+
+// input array  
+$input = array(4, 3, 6, 5, 8, 7, 2); 
+
+$even = array_filter($input,function($val){
+
+    return ($val % 2 == 0)? 1 : -1;
+
+});
+
+$odd = array_filter($input,function($val){
+
+    return ($val % 2 != 0)? 1 : -1;
+
+});
+
+print_r($even);
\ No newline at end of file
diff --git a/Sorting/trivia/simple_uasort.php b/Sorting/trivia/simple_uasort.php
new file mode 100644
index 0000000..7202888
--- /dev/null
+++ b/Sorting/trivia/simple_uasort.php
@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * Simple uasort example
+ */
+
+function simpple_sort(array &$usort): array{
+
+    try{
+
+        if(empty($usort) || count($usort) == 0){
+
+            throw new \Exception("Invalid array, please check array");
+
+        }
+
+        uasort($usort,function($val_1, $val_2){
+
+            if($val_1 > $val_2){
+
+                return 1;
+
+            }else if($val_1 < $val_2){
+
+                return -1;
+
+            }
+
+            return 0;
+
+        });
+
+        return $usort;
+
+    }catch(\Exception $e){
+
+        exit($e->getMessage());
+        echo "\n\n";
+
+    }
+
+}
+
+$arr = array("a" => 4,"b" => 2,"c" => 8,"d" => 6);
+
+$sorted = simpple_sort($arr);
+
+foreach($sorted as $ky => $vl){
+    
+    echo "key = " . $ky . " : " . " value = " . $vl ."\n";
+
+}
+
+echo "\n\n";
\ No newline at end of file
diff --git a/Sorting/trivia/sort_using_index.php b/Sorting/trivia/sort_using_index.php
new file mode 100644
index 0000000..f34001b
--- /dev/null
+++ b/Sorting/trivia/sort_using_index.php
@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * Function will sort array using a predicate index
+ */
+
+function index_sort(array &$sort, int $idx): array{
+
+    try{
+
+        if(empty($sort) || count($sort) == 0){
+
+            throw new \Exception("Invalid array, please check array and try again");
+
+        }
+
+        uasort($sort, function($val_1, $val_2) use($idx) {
+
+            if(!ctype_alpha($val_1) || !ctype_alpha($val_2)){
+
+                return 0;
+
+            }
+
+            if(substr($val_1, $idx) > substr($val_2, $idx)){
+
+                return 1;
+
+            }else if( substr($val_1, $idx) < substr($val_2, $idx) ){
+
+                return -1;
+
+            }
+
+            return 0;
+
+        });
+
+        return $sort;
+
+    }catch(\Exception $e){
+
+        exit($e->getMessage());
+        echo "\n\n";
+
+    }
+
+}
+
+$arr = ['orange', 'banana', 'apple','carrot', 'collard', 'pea'];
+
+$sorted = index_sort($arr, 2);
+
+foreach($sorted as $val){
+
+    echo $val . " ";
+
+}
+
+echo "\n\n";
\ No newline at end of file
diff --git a/Sorting/trivia/sort_using_last_char.php b/Sorting/trivia/sort_using_last_char.php
new file mode 100644
index 0000000..61b5630
--- /dev/null
+++ b/Sorting/trivia/sort_using_last_char.php
@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * Function will sort array using last char in string
+ */
+
+function sort_last_char(array &$usort): array{
+
+    try{
+
+        if(empty($usort) || count($usort) == 0){
+
+            throw new \Exception("Invalid array, please check array and try agaian");
+
+        }
+
+        uasort($usort,function($val_1, $val_2) {
+
+            if(!ctype_alpha($val_1) || !ctype_alpha($val_2)){
+
+                return 0;
+    
+            }    
+
+            if(substr($val_1,-1) > substr($val_2,-1)){
+
+                return 1;
+
+            }else if(substr($val_1,-1) < substr($val_2,-1)){
+
+                return -1;
+
+            }
+
+            return 0;
+
+        });
+
+        return $usort;
+
+    }catch(\Exception $e){
+
+        exit($e->getMessage());
+        echo "\n\n\n\n";
+
+    }
+
+}
+
+$arr = ['orange', 'banana', 'apple','carrot', 'collard', 'pea'];
+
+$sorted_arr = sort_last_char($arr);
+
+foreach($sorted_arr as $val){
+
+    echo $val . " ";
+
+}
+
+echo "\n\n\n\n";
\ No newline at end of file