From 155dae3359ab4c4a4186f81600b292fbda193477 Mon Sep 17 00:00:00 2001
From: shakti1510 <shashankmnshakti95288@gmail.com>
Date: Thu, 12 Sep 2024 00:12:05 +0530
Subject: [PATCH] Rec_Op is a sample for all recursive programs and nd one is
 the user created singly linked list

---
 Programs/Rec_Op.java           | 124 +++++++++++++++++++++++++
 Programs/SinglyLinkedList.java | 161 +++++++++++++++++++++++++++++++++
 2 files changed, 285 insertions(+)
 create mode 100644 Programs/Rec_Op.java
 create mode 100644 Programs/SinglyLinkedList.java

diff --git a/Programs/Rec_Op.java b/Programs/Rec_Op.java
new file mode 100644
index 0000000..82aae9d
--- /dev/null
+++ b/Programs/Rec_Op.java
@@ -0,0 +1,124 @@
+package day1_recursion;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+public class Rec_Op {
+	int bigNum(int n) {
+		return bigNum(n, -9);
+	}
+	int bigNum(int n,int max) {
+		if(n==0)
+			return max;
+		if(max<n%10)
+			return bigNum(n/10,n%10);
+		return bigNum(n/10, max);
+	}
+	int prodDigNum(int n) {
+		if(n<10) {
+			return n;
+		}
+		return n%10*prodDigNum(n/10);
+	}
+	
+	int factNum(int n) {
+		if(n==1||n==0)
+			return 1;
+		return n*factNum(n-1);
+	}
+	int smallNum(int n) {
+		return smallNum(n, 9);
+	}
+	int smallNum(int n,int min) {
+		if(n==0)
+			return min;
+		if(min>n%10)
+			return smallNum(n/10,n%10);
+		return smallNum(n/10, min);
+	}
+	boolean isPerfect(int n) {
+		return isPerfect(n,0,1);
+	}
+	private boolean isPerfect(int n, int s, int d) {
+		if(d>n/2)
+			return s==n;
+		return isPerfect(n,(n%d==0)?s+d:s, d+1);
+	}
+	int countFact(int n) {
+		return countFact(n,1);
+	}
+	private int countFact(int n, int i) {
+		if(i>n/2)
+			return 0;
+		if(n%i==0)
+			return 1+countFact(n,i+1);
+		return countFact(n, i+1);
+	}
+	boolean isPal(String n) {
+		return isPal(n,0,n.length()-1);
+	}
+	private boolean isPal(String n, int f, int l) {
+		if(f>=l)
+			return true;
+		if(n.charAt(f)!=n.charAt(l))
+			return false;
+		return isPal(n, f+1, l-1);
+	}
+	int lcm(int m,int n) {
+		if(m>n)
+			return lcm(n,m);
+		return lcm(m,n,n);
+	}
+	private int lcm(int m, int n, int prod) {
+		if(prod%m==0) {
+			return prod;
+		}
+		return lcm(m,n,prod+n);
+	}
+	int fibNum(int n) {
+		if(n==2||n==1)
+			return n;
+		return fibNum(n-1)+fibNum(n-2);
+	}
+	int binSearch(int[] ar,int n) {
+		Arrays.sort(ar);
+		return binSearch(ar,n,0,ar.length-1);
+	}
+	private int binSearch(int[] ar, int n, int i, int j) {
+		if(i>j)
+			return -1;
+		int m=(i+j)/2;
+		if(ar[m]>n)
+			return binSearch(ar, n, i, m);
+		else if(ar[m]<n)
+			return binSearch(ar, n, m, j);
+		return m;
+	}
+	
+	//Program complexity is 2^n - 1 as for n disc we have to do 2^n - 1
+	void tOHanoi(int n,char s,char t,char d) {
+		if(n==1)
+			System.out.println("disc"+n+"moves from"+s+" to "+d);
+		tOHanoi(n-1, s, d, t);
+		System.out.println("disc"+n+"moves from"+s+" to "+d);
+		tOHanoi(n-1, t, s, d);
+	}
+	int sumEvenDig(int n) {
+		if(n==0)
+			return 0;
+		int d=n%10;
+		if(d%2==0)
+			return d+ sumEvenDig(n/10);
+		return sumEvenDig(n/10);
+	}
+	String decToBin(int d) {
+		if(d==0||d==1)
+			return d+"";
+		return d%2+""+decToBin(d%2);
+	}
+	String decToOct(int d) {
+		if(d<8)
+			return d+"";
+		return d%8+""+decToOct(d/8);
+	}
+}
\ No newline at end of file
diff --git a/Programs/SinglyLinkedList.java b/Programs/SinglyLinkedList.java
new file mode 100644
index 0000000..4ed2e03
--- /dev/null
+++ b/Programs/SinglyLinkedList.java
@@ -0,0 +1,161 @@
+package day2.LinkedList;
+
+public class SinglyLinkedList {
+	static class Node{
+		Object data;
+		Node next;
+		Node(Object data){
+			this.data=data;
+		}
+	}
+	Node head;
+	void add(Object d) {
+		Node n=new Node(d);
+		if(head==null) {
+			head=n;
+			return;
+		}
+		Node t=head;
+		while(t.next!=null)
+			t=t.next;
+		t.next=n;
+	}
+	void addFirst(Object d) {
+		Node n=new Node(d);
+		if(head==null) {
+			head=n;
+			return;
+		}
+		n.next=head;
+		head=n;
+	}
+	void addIndex(Object d,int i) {
+		if(i==0)
+			addFirst(d);
+		Node t=head, n=new Node(d);
+		while(i>1 && t!=null) {
+			t=t.next;
+			i--;
+		}
+		if(i>1 || t==null) {
+			System.out.println("Invalid Index");
+			return;
+		}
+		n.next=t.next;
+		t.next=n;
+	}
+	Object deleteFirst() {
+		if(head==null) {
+			System.out.println("List is Empty");
+			return null;
+		}
+		Object d=head.data;
+		head=head.next;
+		return d;
+	}
+	Object deleteLast() {
+		if(head==null) {
+			System.out.println("List is Empty");
+			return null;
+		}
+		Node t=head,pr=null;
+		while(t.next!=null) {
+			pr=t;
+			t=t.next;
+		}
+		if(pr!=null)
+			pr.next=null;
+		else
+			head=null;
+		return t.data;
+	}
+	Object deleteIndex(int i) {
+		if(i==0)
+			return deleteFirst();
+		Node t=head;
+		while(i>1 && t!=null) {
+			t=t.next;
+			i--;
+		}
+		if(i>1 || t==null || t.next==null) {
+			System.out.println("Invalid Index");
+			return null;
+		}
+		Object d=t.next.data;
+		t.next=t.next.next;
+		return d;
+	}
+	int getSum() {
+		int s=0;
+		Node t=head;
+		while(t!=null)
+			s+=(int)t.data;
+		return s;
+	}
+	boolean searchNode(Object n) {
+		Node t=head;
+		while(t!=null) {
+			if(t.data==n)
+				return true;
+		}
+		return false;
+	}
+	SinglyLinkedList mergeSLL(SinglyLinkedList f,SinglyLinkedList l) {
+		if(f.head==null && l.head!=null)
+			return l;
+		else if(l.head==null)
+			return f;
+		Node t=f.head;
+		while(t.next!=null)
+			t=t.next;
+		t.next=l.head;
+		return f;
+	}
+	void revLL() {
+		Node p=null,n=null,c=head;
+		while(c!=null) {
+			n=c.next;
+			c.next=p;
+			p=c;
+			c=n;
+		}
+		head=p;
+	}
+	SinglyLinkedList convertNTL(int a) {
+		SinglyLinkedList s=new SinglyLinkedList();
+		do {
+			s.addFirst(a%10);
+			a=a/10;
+		}while(a!=0);
+		return s;
+	}
+	SinglyLinkedList addNum(int a,int b) {
+		SinglyLinkedList p=convertNTL(a);
+		SinglyLinkedList q=convertNTL(b);
+		SinglyLinkedList r=new SinglyLinkedList();
+		Node t1=p.head;
+		Node t2=q.head;
+		int cr=0;
+		while(t1!=null && t2!=null) {
+			int sum=(int)t1.data+(int)t2.data+cr;
+			r.addFirst(sum%10);
+			cr=sum/10;
+			t1=t1.next;
+			t2=t2.next;
+		}
+		while(t1!=null) {
+			int sum=(int)t1.data+cr;
+			r.addFirst(sum%10);
+			cr=sum/10;
+			t1=t1.next;
+		}
+		while(t2!=null) {
+			int sum=(int)t2.data+cr;
+			r.addFirst(sum%10);
+			cr=sum/10;
+			t2=t2.next;
+		}
+		return r;
+	}
+	
+}