Fibonacci series

Time O(2^n)
Space O(2^n)

===========================================================
//Sum of elements of array using recursion

public static void main(String args[]) {

int[] a={1,2,3,4,5,6,7,8,9};
System.out.println(findSum(a,a.length));

}
public static int findSum(int[] a, int n)
{
if(n<=0)
return 0;
return a[n-1] + findSum(a,n-1);
}

//Reverse an array
public static void reverse(int[] arr, int i){

if(i>=arr.length/2)
return;

int temp=arr[i];
arr[i]=arr[arr.length-i-1];
arr[arr.length-i-1]=temp;

reverse(arr,i+1);

}
O(n/2)
O(n/2)

=====================================================================

//check if a string is palindrome

public static boolean checkPalindrome(String st, int i){
if(i>=st.length()/2)
return true;
if(st.charAt(i)==st.charAt(st.length()-i-1))
return checkPalindrome(st,i+1);
else
return false;
}
O(n/2)
O(n/2)

=================================================================================

// saydigits - love babbar

public static void main(String args[]) {
sayDigit(12045);

}
public static void sayDigit(int n)
{
if(n>9)
 sayDigit(n/10);

String st="";

switch(n%10)
{
case 0 : st="zero";break;
case 1 : st="one";break;
case 2 : st="two";break;
case 3 : st="three";break;
case 4 : st="four";break;
case 5 : st="five";break;
case 6 : st="six";break;
case 7 : st="seven";break;
case 8 : st="eight";break;
case 9 : st="nine";
}
System.out.print(st+" ");
}

===============================================================

// check if a string is sorted or not

public static void main(String args[]) {
int[] a={1,2,3,5,7,9,11};
System.out.println(sortCheck(a,a.length));

}
public static boolean sortCheck(int[] a, int n){

if(n<2)
return true;

if(a[n-1]<a[n-2])
return false;
return sortCheck(a,n-1);
}

===============================================================

// lsearch using recursion

public static void main(String args[]) {
int[] a={1,2,3,5,7,9,11};
System.out.println(lsearch(a,1,0));

}
public static int lsearch(int[] a, int val, int i)
{
if(i==a.length)
return -1;

if(val==a[i])
return i;

return lsearch(a,val,i+1);
}

===================================================================
// Binary search using recursion

public static void main(String args[])

{
int[] a={1,2,3,5,7,9,11};
System.out.println(binarySearch(a, 0, a.length - 1, 9));

}
public static int binarySearch(int a[], int l, int r, int x)
{
if(r>=l)
{
int mid = l + (r - l) / 2;
if (a[mid] == x)
return mid;
if (a[mid] > x)
return binarySearch(a, l, mid - 1, x);
return binarySearch(a, mid + 1, r, x);
}
return -1;
}

===============================================================
// Get Stair Path - 0 to Nth or Nth to 0; - Pepcoding

import java.util.*;
public class MyClass {
public static void main(String args[])
{
int n = 6;
StringBuilder ds = new StringBuilder();
List<String> ans = new ArrayList<>();
help(n, ds, ans);
System.out.println(ans);
}
public static void help(int remSteps, StringBuilder ds, List<String> ans)
{
if(remSteps == 0)
{
ans.add(ds.toString());
return;
}
if(remSteps < 0)
return;

ds.append(1);
help(remSteps-1, ds, ans);
ds.deleteCharAt(ds.length()-1);

ds.append(2);
help(remSteps-2, ds, ans);
ds.deleteCharAt(ds.length()-1);

ds.append(3);
help(remSteps-3, ds, ans);
ds.deleteCharAt(ds.length()-1);
}
}
===================================================================================
====================

===================================================================================
==========================

// Count stair paths 0 to N th or Nth to 0 - leetcode 70

class Solution {
public int climbStairs(int n) {

if(n==1 || n==2)
return n;

return climbStairs(n-1) + climbStairs(n-2);

}
}

===================================================================================
=====================

// Letter combination of a phone number leetcode 17

class Solution
{
public List<String> letterCombinations(String digits)
{
List<String> result = new ArrayList<>();
if (digits.isEmpty()) return result;

Map<Character, String> map = new HashMap<>();

map.put('2', "abc");
map.put('3', "def");
map.put('4', "ghi");
map.put('5', "jkl");
map.put('6', "mno");
map.put('7', "pqrs");
map.put('8', "tuv");
map.put('9', "wxyz");

StringBuilder currentCombination = new StringBuilder();

backtrack(digits, 0, map, currentCombination, result);

return result;
}

private void backtrack(String digits, int index, Map<Character, String> map,

StringBuilder currentCombination, List<String> result)
{
if (index == digits.length())
{
result.add(currentCombination.toString());
return;
}

char digit = digits.charAt(index);

 String letters = map.get(digit);
for(int i=0;i<letters.length();i++)
{
char k = letters.charAt(i);
currentCombination.append(k);
backtrack(digits, index + 1, map, currentCombination, result);
currentCombination.deleteCharAt(currentCombination.length() - 1); //
Backtrack by removing the last letter added
}
}
}

OR

// gfg - possible words from phone digits

class Solution
{
//Function to find list of all words possible by pressing given numbers.
static ArrayList <String> possibleWords(int a[], int N)
{
ArrayList<String> result = new ArrayList<>();

Map<Integer,String> map = new HashMap<>();

map.put(2,"abc");
map.put(3,"def");
map.put(4,"ghi");
map.put(5,"jkl");
map.put(6,"mno");
map.put(7,"pqrs");
map.put(8,"tuv");
map.put(9,"wxyz");

StringBuilder cc = new StringBuilder();

backtrack(a, 0, cc, map, result);

return result;

}
public static void backtrack(int[] a, int index, StringBuilder cc,
Map<Integer,String> map, ArrayList<String> result)
{
if(index == a.length)
{
result.add(cc.toString());
return;
}

String letters = map.get(a[index]);

for(int i=0; i<letters.length(); i++)

{
char k = letters.charAt(i);
cc.append(k);
backtrack(a, index+1, cc, map, result);
cc.deleteCharAt(cc.length()-1);
}
}
}