Binary Search and Recursion concepts added

Author: suren-rjs

BankingApplication/src/Main.java

@@ -0,0 +1,85 @@
+public class Main {
+ public static void main(String[] args) {
+ // System.out.println(factorial(3));
+ // for (int i = 0; i < 10; i++) {
+ // System.out.print(findFibonacciSeries(i) + " ");
+ // }
+ // System.out.println(reverseString("Hello"));
+ // System.out.println(reverseNumber(456));
+ int[] array = {1, 2, 3, 4, 5};
+ // BinarySearch(array, 10);
+ // printAllPossibleCombinations(array, 3);
+ }
+
+ static void combinationUtil(
+ int[] arr,
+ int arrayLength,
+ int numberOfRegs,
+ int currentIndex,
+ int[] data,
+ int startingIndex) {
+ if (currentIndex == numberOfRegs) {
+ for (int j = 0; j < numberOfRegs; j++) System.out.print(data[j] + " ");
+ System.out.print("\n");
+ return;
+ }
+
+ if (startingIndex >= arrayLength) return;
+
+ data[currentIndex] = arr[startingIndex];
+ combinationUtil(arr, arrayLength, numberOfRegs, currentIndex + 1, data, startingIndex + 1);
+ combinationUtil(arr, arrayLength, numberOfRegs, currentIndex, data, startingIndex + 1);
+ }
+
+ static void printAllPossibleCombinations(int[] arr, int numberOfIndex) {
+ int[] data = new int[numberOfIndex];
+
+ combinationUtil(arr, arr.length, numberOfIndex, 0, data, 0);
+ }
+
+ private static void BinarySearch(int[] array, int number) {
+ int firstData = 0;
+ int lastData = array.length - 1;
+ int i = 0;
+ while (firstData <= lastData) {
+ System.out.println(i++);
+ int middleData = (firstData + lastData) / 2;
+ if (array[middleData] == number) {
+ System.out.println(number + " found at " + middleData);
+ return;
+ } else if (array[middleData] < number) {
+ firstData = middleData + 1;
+ } else if (array[middleData] > number) {
+ lastData = middleData - 1;
+ }
+ }
+ }
+
+ private static int reverseNumber(int integer) {
+ int number = 0;
+ while (integer != 0) {
+ number *= 10;
+ number += (integer % 10);
+ integer /= 10;
+ }
+ return number;
+ }
+
+ private static String reverseString(String text) {
+ String reverseString = "";
+ int StringLength = text.length();
+ while (StringLength > 0) reverseString += text.charAt(--StringLength);
+ return reverseString;
+ }
+
+ private static int findFibonacciSeries(int number) {
+ return (number == 1 || number == 2)
+ ? 1
+ : (number == 0) ? 0 : findFibonacciSeries(number - 1) + findFibonacciSeries(number - 2);
+ }
+
+ private static int factorial(int number) {
+ if (number == 0 || number == 1) return 1;
+ return number * factorial(number - 1);
+ }
+}

RecursionPractice/src/Main.java

@@ -4,6 +4,21 @@ public class Main {
  public static void main(String[] args) {
  int[] intArray = {5, 7, 1, 15, 10, 3, 9};
  insertionSort(intArray);
+ findNextGreaterNumber();
+ }
+
+ private static void findNextGreaterNumber() {
+ int[] inputArray = {4, 5, 2, 25};
+ for (int i = 0; i < inputArray.length; i++) {
+ int currentValue = inputArray[i], j = i, nextGreaterValues = -1;
+ while (++j < inputArray.length) {
+ if (currentValue < inputArray[j]) {
+ nextGreaterValues = inputArray[j];
+ break;
+ }
+ }
+ System.out.print(nextGreaterValues + " ");
+ }
  }
 
  private static void insertionSort(int[] intArray) {

SortingAlgorithm/src/Main.java

@@ -0,0 +1,61 @@
+import java.util.List;
+
+public class BookTaxi {
+
+ public static void BookNewTaxi(
+ int customerId,
+ char pickUpLocation,
+ char dropLocation,
+ int pickUpTime,
+ List<Taxi> freeTaxies) {
+ int min = 999;
+ int DistanceBetweenTaxiAndCustomer;
+ int DistanceBetweenPickupAndDrop;
+ int dropTime = 0;
+ int tripEarning = 0;
+ String tripDetails = null;
+ Taxi BookedTaxi = null;
+
+ for (Taxi currentTaxi : freeTaxies) {
+ DistanceBetweenTaxiAndCustomer =
+ Math.abs((currentTaxi.CurrentLocation - '0') - (pickUpLocation - '0')) * 15;
+ DistanceBetweenPickupAndDrop = Math.abs((dropLocation - '0') - (pickUpLocation - '0')) * 15;
+ if (DistanceBetweenTaxiAndCustomer < min) {
+ BookedTaxi = currentTaxi;
+ dropTime = pickUpTime + DistanceBetweenPickupAndDrop / 15;
+ tripEarning = ((DistanceBetweenPickupAndDrop - 5) * 10 + 100);
+ tripDetails =
+ customerId
+ + " "
+ + customerId
+ + " "
+ + pickUpLocation
+ + " "
+ + dropLocation
+ + " "
+ + pickUpTime
+ + " "
+ + dropTime
+ + " "
+ + tripEarning;
+ min = DistanceBetweenTaxiAndCustomer;
+ }
+ }
+ assert BookedTaxi != null;
+ BookedTaxi.BookingId = customerId;
+ BookedTaxi.CurrentLocation = dropLocation;
+ BookedTaxi.TotalEarnings += tripEarning;
+ BookedTaxi.FreeTime = dropTime;
+ BookedTaxi.TaxiDetails.add(tripDetails);
+ System.out.println("Taxi -> " + BookedTaxi.TaxiNumber + " Booked !");
+ }
+
+ public static void ShowTaxiDetails(Taxi taxi) {
+ System.out.println(
+ "BookingId CustomerId From To PickUpTime DropTime TripEarning\n");
+ for (String detail : taxi.TaxiDetails) System.out.println(detail);
+ System.out.println(
+ "Taxi " + taxi.TaxiNumber + " : Earning -> Rs. " + taxi.TotalEarnings);
+ System.out.println("==================================================================================");
+ }
+}

TaxiBookingApp/src/BookTaxi.java

@@ -0,0 +1,25 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Taxi {
+ static int id = 1;
+ int TaxiNumber;
+ int BookingId;
+ char CurrentLocation;
+ int FreeTime;
+ int TotalEarnings;
+ List<String> TaxiDetails;
+
+ public Taxi() {
+ this.TaxiNumber = id++;
+ this.CurrentLocation = 'A';
+ this.FreeTime = 6;
+ this.TotalEarnings = 0;
+ this.BookingId = 0;
+ this.TaxiDetails = new ArrayList<>();
+ }
+
+ public String toString() {
+ return "";
+ }
+}

TaxiBookingApp/src/Taxi.java

@@ -34,9 +34,12 @@
  *===================================================================================================
  */
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Scanner;
 
-public class Main {
+public class TaxiBookingApplication {
  static int customerId = 1;
 
  public static void main(String[] args) {
@@ -48,7 +51,7 @@ public static void main(String[] args) {
  Scanner input = new Scanner(System.in);
  boolean userWantsToContinue = true;
  // Create No of Taxies
- List<Taxi> allTaxies = createTaxiList(4);
+ List<Taxi> allTaxies = createTaxiList();
 
  while (userWantsToContinue) {
  System.out.println(
@@ -93,13 +96,13 @@ private static List<Taxi> getAllFreeTaxies(
  availableFreeTaxies.add(currentTaxi);
  }
  }
- Collections.sort(availableFreeTaxies, (a, b) -> a.TotalEarnings - b.TotalEarnings);
+ availableFreeTaxies.sort(Comparator.comparingInt(a -> a.TotalEarnings));
  return availableFreeTaxies;
  }
 
- private static List<Taxi> createTaxiList(int noOfTaxi) {
+ private static List<Taxi> createTaxiList() {
  List<Taxi> createdTaxiList = new ArrayList<>();
- for (int i = 0; i < noOfTaxi; i++) {
+ for (int i = 0; i < 4; i++) {
  createdTaxiList.add(new Taxi());
  }
  return createdTaxiList;

TaxiBookingApplication/src/Main.java …okingApp/src/TaxiBookingApplication.javaTaxiBookingApplication/src/Main.java renamed to TaxiBookingApp/src/TaxiBookingApplication.java TaxiBookingApplication/src/Main.java renamed to TaxiBookingApp/src/TaxiBookingApplication.java

@@ -0,0 +1,85 @@
+import java.util.LinkedList;
+
+public class countJumps {
+ public static void main(String[] args) {
+ int[][] inputArray = {
+ {1, 0, 1, 1},
+ {1, 1, 1, 1},
+ {0, 0, 1, 0}
+ };
+ findMinJumps(inputArray);
+ }
+
+ private static void findMinJumps(int[][] inputArray) {
+ int rows = inputArray.length, cols = inputArray[0].length, sx = -1, sy = -1;
+ if ((rows == 0) && (cols == 0)) {
+ System.out.println("No Path Found");
+ return;
+ }
+ for (int i = 0; i < inputArray[0].length; i++) {
+ if (inputArray[0][i] == 1) {
+ sx = 0;
+ sy = i;
+ tryToFindPath(inputArray, sx, sy);
+ }
+ }
+ }
+
+ private static void tryToFindPath(int[][] inputArray, int sx, int sy) {
+ Cell StartCell = new Cell(sx, sy);
+ boolean isValidPath = false;
+ String pathFound = "Path Found from (" + sx + ", " + sy + ")";
+ StartCell.jumpCount = 0;
+ Cell[][] board = new Cell[inputArray.length][inputArray[0].length];
+ for (int i = 0; i < inputArray.length; i++) {
+ for (int j = 0; j < inputArray[0].length; j++) {
+ if (inputArray[i][j] != 0) board[i][j] = new Cell(i, j);
+ }
+ }
+
+ LinkedList<Cell> Queue = new LinkedList<>();
+ Queue.add(StartCell);
+ Cell tempCell;
+ while ((tempCell = Queue.poll()) != null) {
+ if (tempCell.x == inputArray.length - 1) {
+ isValidPath = true;
+ break;
+ }
+
+ startMoving(board, Queue, tempCell.x + 1, tempCell.y, tempCell);
+ startMoving(board, Queue, tempCell.x, tempCell.y + 1, tempCell);
+ }
+
+ if (isValidPath) System.out.println(pathFound + " JumpCounts = " + tempCell.jumpCount);
+ else if (!isValidPath) System.out.println(pathFound + " and is not valid path");
+ }
+
+ private static void startMoving(
+ Cell[][] board, LinkedList<Cell> queue, int x, int y, Cell parentCell) {
+ if (x < 0 || y < 0 || x >= board.length || y >= board[0].length || board[x][y] == null) return;
+ int distance = parentCell.jumpCount + 1;
+ Cell currentCell = board[x][y];
+ if (distance < currentCell.jumpCount) {
+ currentCell.jumpCount = distance;
+ currentCell.nextCell = parentCell;
+ queue.add(currentCell);
+ }
+ }
+
+ public static class Cell {
+ int x, y, jumpCount;
+ Cell nextCell;
+
+ public Cell(int x, int y) {
+ this.x = x;
+ this.y = y;
+ this.jumpCount = Integer.MAX_VALUE;
+ this.nextCell = null;
+ }
+
+ @Override
+ public String toString() {
+ return "(" + x + ", " + y + ")";
+ }
+ }
+}