add Recursion problem set

Author: AhmedLSayed9

Diff for: recursion_problem_set/example1_reverse.dart

@@ -0,0 +1,19 @@
+/// Write a recursive function called reverse which accepts a string and returns a new string in reverse.
+///
+/// reverse('awesome') // 'emosewa'
+/// reverse('rithmschool') // 'loohcsmhtir'
+
+void main() {
+  print(reverse('awesome'));
+}
+
+// Input: String
+// Output: The reverse of the input string
+reverse(String str) {
+  // If the str is empty, then return (the base case).
+  if (str.isEmpty) return str;
+
+  // return last char of str + reverse() of str excluding last char.
+  final lastIndex = str.length - 1;
+  return str[lastIndex] + reverse(str.substring(0, lastIndex));
+}

Diff for: recursion_problem_set/example2_is_palindrome.dart

@@ -0,0 +1,28 @@
+/// Write a recursive function called isPalindrome which returns true if the string
+/// passed to it is a palindrome (reads the same forward and backward). Otherwise it returns false.
+///
+/// isPalindrome('awesome') // false
+/// isPalindrome('foobar') // false
+/// isPalindrome('tacocat') // true
+/// isPalindrome('amanaplanacanalpanama') // true
+/// isPalindrome('amanaplanacanalpandemonium') // false
+
+void main() {
+  print(isPalindrome('tacocat'));
+}
+
+// Input: String
+// Output: bool, if the passed string is palindrome
+bool isPalindrome(String str) {
+  // If str is empty or single char return true (the base case).
+  if (str.length <= 1) return true;
+
+  // compare first and last chars:
+  // if they're the same return isPalindrome of str excluding first and last chars
+  // or else return false
+  final lastIndex = str.length - 1;
+  if (str[0] == str[lastIndex]) {
+    return isPalindrome(str.substring(1, lastIndex));
+  }
+  return false;
+}

Diff for: recursion_problem_set/example3_some_recursive.dart

@@ -0,0 +1,28 @@
+/// Write a recursive function called someRecursive which accepts an array and a callback.
+/// The function returns true if a single value in the array returns true when passed to the callback.
+/// Otherwise it returns false.
+///
+/// someRecursive([1,2,3,4], isOdd) // true
+/// someRecursive([4,6,8,9], isOdd) // true
+/// someRecursive([4,6,8], isOdd) // false
+/// someRecursive([4,6,8], val => val > 10); // false
+
+void main() {
+  print(someRecursive([4, 6, 8], isOdd));
+  print(someRecursive(['a', 'b', 'c'], (String val) => val == 'c'));
+}
+
+bool isOdd(int val) => val % 2 != 0;
+
+// Input: array and a callback
+// Output: bool, if a single value in the array returns true when passed to the callback
+bool someRecursive<T>(List<T> arr, bool Function(T val) callBack) {
+  // If list is empty return false (the base case)
+  if (arr.isEmpty) return false;
+
+  // Test last value of arr at the callBack:
+  // If it returns true then someRecursive should return true
+  // Or else return someRecursive of arr excluding last value
+  if (callBack(arr.last)) return true;
+  return someRecursive(arr..removeLast(), callBack);
+}

Diff for: recursion_problem_set/example4_flatten.dart

@@ -0,0 +1,36 @@
+/// Write a recursive function called flatten which accepts an array of array
+/// and returns a new array with all values flattened.
+///
+/// flatten([1, 2, 3, [4, 5] ]) // [1, 2, 3, 4, 5]
+/// flatten([1, [2, [3, 4], [[5]]]]) // [1, 2, 3, 4, 5]
+/// flatten([[1],[2],[3]]) // [1,2,3]
+/// flatten([[[[1], [[[2]]], [[[[[[[3]]]]]]]]]]) // [1,2,3]
+
+void main() {
+  print(flatten([
+    1,
+    [
+      2,
+      [3, 4],
+      [
+        [5]
+      ]
+    ]
+  ]));
+}
+
+// Input: an array of array
+// Output: new array with all values flattened
+List<dynamic> flatten(List<dynamic> arr) {
+  // If arr is empty return it (the base case)
+  if (arr.isEmpty) return arr;
+
+  // Start from last item:
+  // if it's a list: return flatten of arr excluding last item + flatten of last item (as it's a list)
+  // or else, return flatten of arr excluding last item + last item
+  final newArray = arr.sublist(0, arr.length - 1);
+  if (arr.last is List) {
+    return [...flatten(newArray), ...flatten(arr.last)];
+  }
+  return [...flatten(newArray), arr.last];
+}